// Machine generated IDispatch wrapper class(es) created with ClassWizard
/////////////////////////////////////////////////////////////////////////////
// IFCFCommand wrapper class

namespace pcdlrn
{


class IFCFCommand : public COleDispatchDriver
{
public:
	IFCFCommand() {}		// Calls COleDispatchDriver default constructor
	IFCFCommand(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IFCFCommand(const IFCFCommand& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	CString GetId();
	void SetId(LPCTSTR);
	BOOL GetHasProfileDimension();
	void SetHasProfileDimension(BOOL);
	LPDISPATCH GetProfileDimension();
	void SetProfileDimension(LPDISPATCH);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IApplication wrapper class

class IApplication : public COleDispatchDriver
{
public:
	IApplication() {}		// Calls COleDispatchDriver default constructor
	IApplication(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IApplication(const IApplication& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetPartPrograms();
	void SetPartPrograms(LPDISPATCH);
	LPDISPATCH GetActivePartProgram();
	void SetActivePartProgram(LPDISPATCH);
	CString GetDefaultFilePath();
	void SetDefaultFilePath(LPCTSTR);
	CString GetCaption();
	void SetCaption(LPCTSTR);
	CString GetFullName();
	void SetFullName(LPCTSTR);
	CString GetPath();
	void SetPath(LPCTSTR);
	CString GetName();
	void SetName(LPCTSTR);
	BOOL GetVisible();
	void SetVisible(BOOL);
	CString GetStatusBar();
	void SetStatusBar(LPCTSTR);
	long GetLeft();
	void SetLeft(long);
	long GetWidth();
	void SetWidth(long);
	long GetTop();
	void SetTop(long);
	long GetHeight();
	void SetHeight(long);
	BOOL GetOperatorMode();
	void SetOperatorMode(BOOL);
	BOOL GetUserExit();
	void SetUserExit(BOOL);
	LPDISPATCH GetMachines();
	void SetMachines(LPDISPATCH);
	CString GetDefaultMachineName();
	void SetDefaultMachineName(LPCTSTR);
	CString GetDefaultProbeFile();
	void SetDefaultProbeFile(LPCTSTR);
	LPDISPATCH GetApplicationEvents();
	void SetApplicationEvents(LPDISPATCH);
	BOOL GetRemotePanelMode();
	void SetRemotePanelMode(BOOL);
	long GetMajorVersion();
	void SetMajorVersion(long);
	long GetMinorVersion();
	void SetMinorVersion(long);
	CString GetVersionString();
	void SetVersionString(LPCTSTR);
	long GetErrorDialogEnabled();
	void SetErrorDialogEnabled(long);
	BOOL GetConnectedToSlave();
	void SetConnectedToSlave(BOOL);
	BOOL GetConnectedToMaster();
	void SetConnectedToMaster(BOOL);
	BOOL GetAdminPrivileges();
	void SetAdminPrivileges(BOOL);
	long GetVerboseDialogs();
	void SetVerboseDialogs(long);
	CString GetCurrentUserDirectory();
	void SetCurrentUserDirectory(LPCTSTR);
	BOOL GetConnectedInDriveMode();
	void SetConnectedInDriveMode(BOOL);
	BOOL GetConnectedInRelayMode();
	void SetConnectedInRelayMode(BOOL);
	LPDISPATCH GetApplicationSettings();
	void SetApplicationSettings(LPDISPATCH);
	long GetLocaleID();
	void SetLocaleID(long);
	LPDISPATCH GetReportTemplates();
	void SetReportTemplates(LPDISPATCH);
	LPDISPATCH GetLabelTemplates();
	void SetLabelTemplates(LPDISPATCH);
	CString GetGetStringSetting();
	void SetGetStringSetting(LPCTSTR);
	double GetGetDoubleSetting();
	void SetGetDoubleSetting(double);
	long GetGetIntSetting();
	void SetGetIntSetting(long);
	long GetGetDWORDSetting();
	void SetGetDWORDSetting(long);
	BOOL GetGetBoolSetting();
	void SetGetBoolSetting(BOOL);
	LPDISPATCH GetPortLock();
	void SetPortLock(LPDISPATCH);
	long GetReleaseType();
	void SetReleaseType(long);
	CString GetReleaseTypeName();
	void SetReleaseTypeName(LPCTSTR);
	LPDISPATCH GetNotificationSettings();
	void SetNotificationSettings(LPDISPATCH);
	CString Get_Name();
	void Set_Name(LPCTSTR);

// Operations
public:
	void Help(LPCTSTR HelpFile, long HelpContext, LPCTSTR HelpString);
	void Restore();
	void Minimize();
	void Maximize();
	BOOL SetActive();
	BOOL Post(LPCTSTR Source, LPCTSTR Destination);
	void Quit();
	LPDISPATCH SpawnNewInstance();
	BOOL WaitUntilReady(long TimeOutInSeconds);
	BOOL WriteRegistryString(LPCTSTR lpszSection, LPCTSTR lpszEntry, LPCTSTR lpszValue, BOOL bSetVariable);
	CString GetRegistryString(LPCTSTR lpszSection, LPCTSTR lpszEntry, LPCTSTR lpszDefault);
	BOOL WriteRegistryDouble(LPCTSTR lpszSection, LPCTSTR lpszEntry, double dValue, BOOL bSetVariable);
	double GetRegistryDouble(LPCTSTR lpszSection, LPCTSTR lpszEntry, double dDefault);
	BOOL WriteRegistryInt(LPCTSTR lpszSection, LPCTSTR lpszEntry, long nValue, BOOL bSetVariable);
	long GetRegistryInt(LPCTSTR lpszSection, LPCTSTR lpszEntry, long nDefault);
	BOOL WriteRegistryBool(LPCTSTR lpszSection, LPCTSTR lpszEntry, BOOL bValue, BOOL bSetVariable);
	BOOL GetRegistryBool(LPCTSTR lpszSection, LPCTSTR lpszEntry, BOOL bDefault);
	BOOL WriteRegistryDWORD(LPCTSTR lpszSection, LPCTSTR lpszEntry, long dwValue, BOOL bSetVariable);
	long GetRegistryDWORD(LPCTSTR lpszSection, LPCTSTR lpszEntry, long dwDefault);
	BOOL WriteRegistryPoint(LPCTSTR lpszSection, LPCTSTR lpszEntry, double dX, double dY, double dZ, BOOL bSetVariable);
	LPDISPATCH GetRegistryPoint(LPCTSTR lpszSection, LPCTSTR lpszEntry, double dX, double dY, double dZ);
	BOOL RegistryKeyExists(LPCTSTR lpszSection);
	BOOL RegistryValueExists(LPCTSTR lpszSection, LPCTSTR lpszEntry);
	BOOL DeleteRegistryValue(LPCTSTR lpszSection, LPCTSTR lpszEntry);
	BOOL DeleteRegistryKey(LPCTSTR lpszSection);
	LPDISPATCH GetRegistrySettings();
	void _AddRegistrySetting(LPCTSTR szSection, LPCTSTR szEntry, LPCTSTR szDefault, long nType, long nFunction, BOOL bUserAdmin, BOOL bAutoEnabled, BOOL bSingleton);
	long ExportRegistrySettings(LPCTSTR FilePath);
	long ImportRegistrySettings(LPCTSTR FilePath);
	CString GetHelpMap(long MenuId);
	void WriteRegistrySettings();
	void WinHelp(long dwData, long nCmd);
	long SwitchLanguageFiles(long fromLang, long toLang);
	void ChangeLanguage(long NewLanguage);
	BOOL PartProgramMirror(LPCTSTR szPartProgramPathName, LPCTSTR szTargetProgramPathName, LPCTSTR szReferencePathName, long PartMirrorAxix, long ReporingMirrorOption, long MachineMirrorAxis);
	CString GetRegistryRoot();
	CString GetSystemHiddenFolder(BOOL bVersionSpecific);
	CString GetSystemDocuments(BOOL bVersionSpecific);
	CString GetUserHiddenFolder(BOOL bVersionSpecific);
	CString GetUserVisibleFolder(BOOL bVersionSpecific);
	CString GetSystemReportingFolder(BOOL bVersionSpecific);
	BOOL PartProgramMirror2(LPCTSTR szPartProgramPathName, LPCTSTR szTargetProgramPathName, LPCTSTR szReferencePathName, long PartMirrorAxix, long ReporingMirrorOption, long MachineMirrorAxis, BOOL DoNotMirrorCAD);
};
/////////////////////////////////////////////////////////////////////////////
// IPartPrograms wrapper class

class IPartPrograms : public COleDispatchDriver
{
public:
	IPartPrograms() {}		// Calls COleDispatchDriver default constructor
	IPartPrograms(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IPartPrograms(const IPartPrograms& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetCount();
	void SetCount(long);
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);

// Operations
public:
	LPDISPATCH Item(const VARIANT& NameorNum);
	void CloseAll();
	BOOL Remove(const VARIANT& NameorNum);
	LPDISPATCH Open(LPCTSTR filename, LPCTSTR MachineName);
	LPDISPATCH Add(LPCTSTR Name, long Units, LPCTSTR Machine, LPCTSTR ProbeFile);
	LPDISPATCH _Item(const VARIANT& NameorNum);
};
/////////////////////////////////////////////////////////////////////////////
// IPartProgram wrapper class

class IPartProgram : public COleDispatchDriver
{
public:
	IPartProgram() {}		// Calls COleDispatchDriver default constructor
	IPartProgram(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IPartProgram(const IPartProgram& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	CString GetPartName();
	void SetPartName(LPCTSTR);
	CString GetPath();
	void SetPath(LPCTSTR);
	CString GetRevisionNumber();
	void SetRevisionNumber(LPCTSTR);
	CString GetSerialNumber();
	void SetSerialNumber(LPCTSTR);
	CString GetFullName();
	void SetFullName(LPCTSTR);
	CString GetName();
	void SetName(LPCTSTR);
	BOOL GetVisible();
	void SetVisible(BOOL);
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	LPDISPATCH GetEditWindow();
	void SetEditWindow(LPDISPATCH);
	LPDISPATCH GetCommands();
	void SetCommands(LPDISPATCH);
	LPDISPATCH GetOldBasic();
	void SetOldBasic(LPDISPATCH);
	LPDISPATCH GetCadWindows();
	void SetCadWindows(LPDISPATCH);
	LPDISPATCH GetTools();
	void SetTools(LPDISPATCH);
	LPDISPATCH GetProbes();
	void SetProbes(LPDISPATCH);
	LPDISPATCH GetActiveMachine();
	void SetActiveMachine(LPDISPATCH);
	long GetUnits();
	void SetUnits(long);
	long GetSpeed();
	void SetSpeed(long);
	BOOL GetExecuteDialogVisible();
	void SetExecuteDialogVisible(BOOL);
	LPDISPATCH GetMasterSlaveDlg();
	void SetMasterSlaveDlg(LPDISPATCH);
	BOOL GetConnectedToSlave();
	void SetConnectedToSlave(BOOL);
	BOOL GetConnectedToMaster();
	void SetConnectedToMaster(BOOL);
	BOOL GetExecutionWasCancelled();
	void SetExecutionWasCancelled(BOOL);
	LPDISPATCH GetCadModel();
	void SetCadModel(LPDISPATCH);
	LPDISPATCH GetPartProgramSettings();
	void SetPartProgramSettings(LPDISPATCH);
	BOOL GetConnectedInDriveMode();
	void SetConnectedInDriveMode(BOOL);
	BOOL GetConnectedInRelayMode();
	void SetConnectedInRelayMode(BOOL);
	LPDISPATCH GetExecutedCommands();
	void SetExecutedCommands(LPDISPATCH);
	CString GetEditWindowTextAll();
	void SetEditWindowTextAll(LPCTSTR);
	long GetStatsCount();
	void SetStatsCount(long);
	LPDISPATCH GetReportWindow();
	void SetReportWindow(LPDISPATCH);
	long GetCurrentArm();
	void SetCurrentArm(long);
	BOOL GetNoActiveProbesObject();
	void SetNoActiveProbesObject(BOOL);
	CString GetCurrentProbeName();
	void SetCurrentProbeName(LPCTSTR);
	BOOL GetShowAllIDs();
	void SetShowAllIDs(BOOL);
	LPDISPATCH GetQuickStart();
	void SetQuickStart(LPDISPATCH);
	BOOL GetReadoutEnabled();
	void SetReadoutEnabled(BOOL);
	LPDISPATCH GetBundledStations();
	void SetBundledStations(LPDISPATCH);
	CString GetOutputFileName();
	void SetOutputFileName(LPCTSTR);
	BOOL GetExecOptStopButtonVisible();
	void SetExecOptStopButtonVisible(BOOL);
	BOOL GetExecOptSkipButtonVisible();
	void SetExecOptSkipButtonVisible(BOOL);
	BOOL GetExecOptContinueButtonVisible();
	void SetExecOptContinueButtonVisible(BOOL);
	BOOL GetExecOptJumpButtonVisible();
	void SetExecOptJumpButtonVisible(BOOL);
	BOOL GetMarkChildMode();
	void SetMarkChildMode(BOOL);
	BOOL GetMarkParentMode();
	void SetMarkParentMode(BOOL);
	long GetMarkNewAlignmentMode();
	void SetMarkNewAlignmentMode(long);
	long GetProgramVersionSchema();
	void SetProgramVersionSchema(long);
	CString GetProgramVersionName();
	void SetProgramVersionName(LPCTSTR);
	CString Get_Name();
	void Set_Name(LPCTSTR);

// Operations
public:
	void Close();
	BOOL Export(LPCTSTR Name);
	BOOL Import(LPCTSTR Name);
	BOOL Quit();
	BOOL Save();
	BOOL SaveAs(LPCTSTR Name);
	void Activate();
	BOOL EXECUTE();
	long MessageBox(LPCTSTR Message, LPCTSTR TITLE, long Type);
	BOOL AsyncExecute();
	LPDISPATCH GetVariableValue(LPCTSTR VarName);
	BOOL SetVariableValue(LPCTSTR VarName, LPDISPATCH Value);
	BOOL DmisOut(long bExecOrder, LPCTSTR filename);
	void RefreshPart();
	long OverrideExecuteSpeed(long NewSpeed);
	void ToggleMasterSlaveMode();
	BOOL LoadLayout(LPCTSTR LayoutFileName);
	BOOL IsProbeAnalog(long ArmNumber);
	BOOL SetExecutionBlock(LPDISPATCH StartCommand, LPDISPATCH EndCommand);
	void ClearExecutionBlock();
	BOOL RunJournalFile(LPCTSTR lpszJFileName);
	BOOL WaitUntilExecuted(LPDISPATCH Command, long timeout, long Arm);
	void EditRulesFile(LPCTSTR filename);
	BOOL ClearTADs();
	BOOL ClearAllTADs();
	BOOL DmisOut2(long bExecOrder, LPCTSTR filename, long bOutputLastInstanceOnly);
	BOOL AutoCreateGroupsForBMWMessPrograms(long bUseDimensionName);
	BOOL SetVerifyFeaturesFlag();
	BOOL ClearVerifyFeaturesFlag();
	BOOL IgnoreLearnModeHits(long bState);
	BOOL ImportUGDCI(LPCTSTR Name);
	void ExternalCommandEvent(long CommandId, long EventId);
	LPDISPATCH CalcAdjustTransform(LPCTSTR Part1AlignID, LPCTSTR Part2AlignID);
	LPDISPATCH Guess(long featType, long addFeat);
	BOOL RemoveLastLearnHit();
	LPDISPATCH CreateGuessWithDimension(long featType, long addFeat, LPCTSTR dimID, double nom1, double nom2, double Plus, double Minus, double form, long mmUnits, long includeLocation, LPDISPATCH refCmd);
	LPDISPATCH GetExecutionWindow(long Arm);
	void SetIPPlanVersion(LPCTSTR UID, long version);
	BOOL SetExecutionMarkedSet(const VARIANT& NameorNum);
	void ClearExecutionMarkedSet();
	long GetExecutionMarkedSetIndex();
	long GetMarkedSetName(long index, BSTR* markedSetName);
	long GetMarkedSetNumbers(long* mazAllowedMarkedSets, long* markedSetCount);
	LPDISPATCH GetReadoutWindow(long Arm);
	void ExportToXML(LPCTSTR filename);
	void ImportXML(LPCTSTR filename);
	void SetupFeatureBasedMeasurement(LPCTSTR filename);
	BOOL SaveAs2(LPCTSTR Name, BOOL CadAsReference);
	VARIANT GetAvailableSchemasForSaveAs(BOOL bSchemaNumbers);
	BOOL SaveAs3(LPCTSTR Name, const VARIANT& NameOrSchema, BOOL CadAsReference);
	void ExecuteMiniRoutineByName(LPCTSTR Name, BOOL AlignmentDependencies);
	void ExecuteMiniRoutineByUID(LPCTSTR UID, BOOL AlignmentDependencies);
	void CopyAutoFeatureInspectionPlannerSettingsIntoRegistryDefaultSettings();
	void SetCadEqualPart(LPCTSTR AlignID);
};
/////////////////////////////////////////////////////////////////////////////
// IEditWindow wrapper class

class IEditWindow : public COleDispatchDriver
{
public:
	IEditWindow() {}		// Calls COleDispatchDriver default constructor
	IEditWindow(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IEditWindow(const IEditWindow& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	BOOL GetVisible();
	void SetVisible(BOOL);
	long GetLeft();
	void SetLeft(long);
	long GetWidth();
	void SetWidth(long);
	long GetTop();
	void SetTop(long);
	long GetHeight();
	void SetHeight(long);
	BOOL GetShowFeatures();
	void SetShowFeatures(BOOL);
	BOOL GetShowAlignments();
	void SetShowAlignments(BOOL);
	BOOL GetShowMoves();
	void SetShowMoves(BOOL);
	BOOL GetShowComments();
	void SetShowComments(BOOL);
	BOOL GetShowDimensions();
	void SetShowDimensions(BOOL);
	BOOL GetShowHits();
	void SetShowHits(BOOL);
	BOOL GetShowOutTolOnly();
	void SetShowOutTolOnly(BOOL);
	BOOL GetShowTips();
	void SetShowTips(BOOL);
	BOOL GetShowHeaderFooter();
	void SetShowHeaderFooter(BOOL);
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	BOOL Get_Visible();
	void Set_Visible(BOOL);

// Operations
public:
	void CommandMode();
	void ReportMode();
	void SetPrintOptions(long Location, long Draft, long Filemode, long ExtNum);
	void PrintEditWindow();
	void SetPrintOptionsEx(long Location, long Draft, long Filemode, long ExtNum, LPCTSTR filename, long format, BOOL bHyperReportsInline);
	void SetDMISOutputOptions(BOOL bEnable, LPCTSTR filename, long bOverwrite, long bOutputTheos, BOOL bOutputFeatWithDimensions);
	void LastExecutionReportMode();
	void DMISMode();
	CString GetCommandText(LPDISPATCH Command);
	void SummaryMode();
	void SelectCommand();
	void CopySelectedToClipboard();
	void PasteFromClipboard();
	long SetPasteWithPatternMirror(long Type);
	void PasteFromClipboardWithPattern();
};
/////////////////////////////////////////////////////////////////////////////
// ICommand wrapper class

class ICommand : public COleDispatchDriver
{
public:
	ICommand() {}		// Calls COleDispatchDriver default constructor
	ICommand(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ICommand(const ICommand& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	CString Get_id();
	void Set_id(LPCTSTR);
	long GetCount();
	void SetCount(long);
	long GetFeature();
	void SetFeature(long);
	CString GetId();
	void SetId(LPCTSTR);
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetType();
	void SetType(long);
	LPDISPATCH GetAlignmentCommand();
	void SetAlignmentCommand(LPDISPATCH);
	LPDISPATCH GetDimensionCommand();
	void SetDimensionCommand(LPDISPATCH);
	LPDISPATCH GetFeatureCommand();
	void SetFeatureCommand(LPDISPATCH);
	LPDISPATCH GetModalCommand();
	void SetModalCommand(LPDISPATCH);
	LPDISPATCH GetMoveCommand();
	void SetMoveCommand(LPDISPATCH);
	LPDISPATCH GetFlowControlCommand();
	void SetFlowControlCommand(LPDISPATCH);
	LPDISPATCH GetBasicScanCommand();
	void SetBasicScanCommand(LPDISPATCH);
	BOOL GetIsAlignment();
	void SetIsAlignment(BOOL);
	BOOL GetIsFeature();
	void SetIsFeature(BOOL);
	BOOL GetIsBasicScan();
	void SetIsBasicScan(BOOL);
	BOOL GetIsDimension();
	void SetIsDimension(BOOL);
	BOOL GetIsFlowControl();
	void SetIsFlowControl(BOOL);
	BOOL GetIsModal();
	void SetIsModal(BOOL);
	BOOL GetIsMove();
	void SetIsMove(BOOL);
	BOOL GetMarked();
	void SetMarked(BOOL);
	LPDISPATCH GetCalibrationCommand();
	void SetCalibrationCommand(LPDISPATCH);
	BOOL GetIsCalibration();
	void SetIsCalibration(BOOL);
	LPDISPATCH GetAttachCommand();
	void SetAttachCommand(LPDISPATCH);
	BOOL GetIsAttach();
	void SetIsAttach(BOOL);
	LPDISPATCH GetExternalCommand();
	void SetExternalCommand(LPDISPATCH);
	BOOL GetIsExternalCommand();
	void SetIsExternalCommand(BOOL);
	LPDISPATCH GetOptionProbeCommand();
	void SetOptionProbeCommand(LPDISPATCH);
	BOOL GetIsOptionProbe();
	void SetIsOptionProbe(BOOL);
	LPDISPATCH GetLeapfrogCommand();
	void SetLeapfrogCommand(LPDISPATCH);
	BOOL GetIsLeapfrog();
	void SetIsLeapfrog(BOOL);
	LPDISPATCH GetOptMotionCommand();
	void SetOptMotionCommand(LPDISPATCH);
	BOOL GetIsOptMotion();
	void SetIsOptMotion(BOOL);
	LPDISPATCH GetArrayIndexCommand();
	void SetArrayIndexCommand(LPDISPATCH);
	BOOL GetIsArrayIndex();
	void SetIsArrayIndex(BOOL);
	LPDISPATCH GetFileIOCommand();
	void SetFileIOCommand(LPDISPATCH);
	BOOL GetIsFileIOCommand();
	void SetIsFileIOCommand(BOOL);
	LPDISPATCH GetTempCompCommand();
	void SetTempCompCommand(LPDISPATCH);
	BOOL GetIsTempComp();
	void SetIsTempComp(BOOL);
	LPDISPATCH GetDisplayMetaFileCommand();
	void SetDisplayMetaFileCommand(LPDISPATCH);
	BOOL GetIsDisplayMetaFile();
	void SetIsDisplayMetaFile(BOOL);
	LPDISPATCH GetCommentCommand();
	void SetCommentCommand(LPDISPATCH);
	BOOL GetIsComment();
	void SetIsComment(BOOL);
	LPDISPATCH GetStatisticCommand();
	void SetStatisticCommand(LPDISPATCH);
	BOOL GetIsStatistic();
	void SetIsStatistic(BOOL);
	LPDISPATCH GetTraceFieldCommand();
	void SetTraceFieldCommand(LPDISPATCH);
	BOOL GetIsTraceField();
	void SetIsTraceField(BOOL);
	LPDISPATCH GetActiveTipCommand();
	void SetActiveTipCommand(LPDISPATCH);
	BOOL GetIsActiveTip();
	void SetIsActiveTip(BOOL);
	LPDISPATCH GetLoadProbeCommand();
	void SetLoadProbeCommand(LPDISPATCH);
	BOOL GetIsLoadProbe();
	void SetIsLoadProbe(BOOL);
	LPDISPATCH GetDimFormatCommand();
	void SetDimFormatCommand(LPDISPATCH);
	BOOL GetIsDimFormat();
	void SetIsDimFormat(BOOL);
	LPDISPATCH GetDimInfoCommand();
	void SetDimInfoCommand(LPDISPATCH);
	BOOL GetIsDimInfo();
	void SetIsDimInfo(BOOL);
	LPDISPATCH GetLoadMachineCommand();
	void SetLoadMachineCommand(LPDISPATCH);
	BOOL GetIsLoadMachine();
	void SetIsLoadMachine(BOOL);
	LPDISPATCH GetScanCommand();
	void SetScanCommand(LPDISPATCH);
	BOOL GetIsScan();
	void SetIsScan(BOOL);
	BOOL GetIsHit();
	void SetIsHit(BOOL);
	BOOL GetIsMeasuredFeature();
	void SetIsMeasuredFeature(BOOL);
	BOOL GetIsConstructedFeature();
	void SetIsConstructedFeature(BOOL);
	BOOL GetIsDCCFeature();
	void SetIsDCCFeature(BOOL);
	BOOL GetSlaveArm();
	void SetSlaveArm(BOOL);
	BOOL GetShowIDOnCad();
	void SetShowIDOnCad(BOOL);
	BOOL GetCopyMeasToNom();
	void SetCopyMeasToNom(BOOL);
	CString GetTypeDescription();
	void SetTypeDescription(LPCTSTR);
	LPDISPATCH GetDataTypes();
	void SetDataTypes(LPDISPATCH);
	BOOL GetMasterArm();
	void SetMasterArm(BOOL);
	BOOL GetBothArms();
	void SetBothArms(BOOL);
	BOOL GetRecalculateINOUT();
	void SetRecalculateINOUT(BOOL);
	BOOL GetHasBreakpoint();
	void SetHasBreakpoint(BOOL);
	long GetItemIndex();
	void SetItemIndex(long);
	BOOL GetSkipped();
	void SetSkipped(BOOL);
	BOOL GetTracksErrors();
	void SetTracksErrors(BOOL);
	BOOL GetMissedHit();
	void SetMissedHit(BOOL);
	BOOL GetUnexpectedHit();
	void SetUnexpectedHit(BOOL);
	BOOL GetExpectsMiss();
	void SetExpectsMiss(BOOL);
	long GetSlotType();
	void SetSlotType(long);
	LPDISPATCH GetDimensionEndCommand();
	void SetDimensionEndCommand(LPDISPATCH);
	long GetUserDefinedUniqueID();
	void SetUserDefinedUniqueID(long);
	BOOL GetIsToolkitCommand();
	void SetIsToolkitCommand(BOOL);
	LPDISPATCH GetToolkitInternalCommands();
	void SetToolkitInternalCommands(LPDISPATCH);
	CString GetDisplayID();
	void SetDisplayID(LPCTSTR);
	LPDISPATCH GetStrategies();
	void SetStrategies(LPDISPATCH);
	BOOL GetIsFCFCommand();
	void SetIsFCFCommand(BOOL);
	LPDISPATCH GetFCFCommand();
	void SetFCFCommand(LPDISPATCH);

// Operations
public:
	BOOL Next();
	BOOL Prev();
	void Remove();
	BOOL Dialog();
	LPDISPATCH Item(long Num);
	BOOL Dialog2(LPDISPATCH* DialogObject);
	BOOL SetExpression(LPCTSTR Expression, long FieldType, long TypeIndex);
	CString GetExpression(long FieldType, long TypeIndex);
	void RemoveExpression(long FieldType, long TypeIndex);
	BOOL EXECUTE();
	void Mark();
	CString GetText(long DataType, long TypeIndex);
	BOOL PutText(LPCTSTR NewVal, long DataType, long TypeIndex);
	void ReDraw();
	void GetUniqueID(long* HiPart, long* LoPart);
	BOOL IsExpressionValid(LPCTSTR Expression);
	LPDISPATCH SolveExpression(LPCTSTR Expression);
	CString GetToggleString(long DataType, long TypeIndex);
	BOOL SetSlaveArm();
	BOOL SetMasterArm();
	BOOL SetBothArms();
	BOOL SetToggleString(long ToggleIndex, long DataType, long TypeIndex);
	LPDISPATCH OptimizedSolveExpression(LPCTSTR Expression);
	BOOL OptimizedSetExpression(LPCTSTR Expression, long FieldType, long TypeIndex);
	VARIANT GetGetFieldValue(long DataType, long TypeIndex);
	BOOL GetHasField(long DataType, long TypeIndex);
	long GetGetToggleValue(long DataType, long TypeIndex);
	long GetGetDataTypeCount(long DataType);
	void UpdateDimensionNominals(BOOL UpdateObjectText);
	VARIANT GetToolkitData(LPCTSTR sToolkitKey);
	BOOL PutToolkitData(const VARIANT& Value, LPCTSTR sToolkitKey);
	LPDISPATCH ToggleCommandType(const VARIANT& MinorWordOrToggleIndex);
	long GetGetDataTypeCountUniqueIndex(long DataType, long TypeIndex);
	BOOL RemoveBundleInstance(long StationIndex);
	LPDISPATCH GetBundleInstance(long StationIndex);
	BOOL AddBundleInstance(long StationIndex);
	BOOL CreateBundleFeatures();
	BOOL IsBundledCommand();
	BOOL Compute();
};
/////////////////////////////////////////////////////////////////////////////
// ICommands wrapper class

class ICommands : public COleDispatchDriver
{
public:
	ICommands() {}		// Calls COleDispatchDriver default constructor
	ICommands(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ICommands(const ICommands& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetCount();
	void SetCount(long);
	LPDISPATCH GetLastCommand();
	void SetLastCommand(LPDISPATCH);
	LPDISPATCH GetCurrentCommand();
	void SetCurrentCommand(LPDISPATCH);
	LPDISPATCH GetCurrentAlignment();
	void SetCurrentAlignment(LPDISPATCH);

// Operations
public:
	BOOL InsertionPointAfter(LPDISPATCH Command);
	BOOL MarkAll(BOOL MarkManual);
	BOOL ClearMarked();
	LPDISPATCH Add(long Type, BOOL AutoPosition);
	LPDISPATCH Item(const VARIANT& NameorNum);
	LPDISPATCH FindByUniqueID(long HiPart, long LoPart);
	BOOL ClearAllBreakpoints();
	void RemoveCommandRange(LPDISPATCH StartCommand, LPDISPATCH EndCommad);
	CString AddConstPointWithValues(long Type, LPCTSTR X, LPCTSTR Y, LPCTSTR Z, BOOL AutoPosition);
	LPDISPATCH AddDimensionWithValues(long Type, LPCTSTR strRefID, LPCTSTR strArrowMult, LPCTSTR strStdDev, BOOL AutoPosition);
	VARIANT AddMultiConstPoints(long Type, const VARIANT& PointArray, BOOL AutoPosition);
	LPDISPATCH AddByCreationGuid(LPCTSTR GuidAsString, BOOL AutoPosition);
//	BOOL SetCurrentCommand(LPDISPATCH Command);
	LPDISPATCH _Item(const VARIANT& NameorNum);
};
/////////////////////////////////////////////////////////////////////////////
// IAlignCommand wrapper class

class IAlignCommand : public COleDispatchDriver
{
public:
	IAlignCommand() {}		// Calls COleDispatchDriver default constructor
	IAlignCommand(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IAlignCommand(const IAlignCommand& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetAboutAxis();
	void SetAboutAxis(long);
	long GetAxis();
	void SetAxis(long);
	CString GetExternalID();
	void SetExternalID(LPCTSTR);
	CString GetFeatID();
	void SetFeatID(LPCTSTR);
	CString GetFeatID2();
	void SetFeatID2(LPCTSTR);
	BOOL GetFindCad();
	void SetFindCad(BOOL);
	CString GetId();
	void SetId(LPCTSTR);
	CString GetInitID();
	void SetInitID(LPCTSTR);
	BOOL GetMeasAllFeat();
	void SetMeasAllFeat(BOOL);
	double GetOffset();
	void SetOffset(double);
	double GetPointTolerance();
	void SetPointTolerance(double);
	BOOL GetRepierceCad();
	void SetRepierceCad(BOOL);
	BOOL GetUseBodyAxis();
	void SetUseBodyAxis(BOOL);
	long GetWorkplane();
	void SetWorkplane(long);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetNumInputs();
	void SetNumInputs(long);
	LPDISPATCH GetAngle();
	void SetAngle(LPDISPATCH);
	LPDISPATCH GetBFOffset();
	void SetBFOffset(LPDISPATCH);
	BOOL GetAverageError();
	void SetAverageError(BOOL);
	CString GetExternalFileID();
	void SetExternalFileID(LPCTSTR);
	LPDISPATCH GetMachineToPartMatrix();
	void SetMachineToPartMatrix(LPDISPATCH);
	LPDISPATCH GetCadToPartMatrix();
	void SetCadToPartMatrix(LPDISPATCH);
	BOOL GetMeasAllFeatAlways();
	void SetMeasAllFeatAlways(BOOL);
	long GetIterativeLevelAxis();
	void SetIterativeLevelAxis(long);
	long GetIterativeRotateAxis();
	void SetIterativeRotateAxis(long);
	long GetIterativeOriginAxis();
	void SetIterativeOriginAxis(long);

// Operations
public:
	BOOL AddLevelFeat(LPCTSTR ID);
	BOOL AddRotateFeat(LPCTSTR ID);
	BOOL AddOriginFeat(LPCTSTR ID);
	BOOL AddBestFitFeat(LPCTSTR ID, double Tolerance);
	void CalculateMatrices();
	BOOL CalculateDeviation(long Item, double* deviation_before, double* ijk_before, double* deviation_after, double* ijk_after);
	void CalculateStatistics(double* MEAN, double* STDDEV);
	CString GetFeatureIdByIndex(long index);
	void GetBFIterations(long* max_iterations, long* actual_iterations);
	BOOL CalculateDeviation2(long Item, long* nAxisUsed, double* dTheoXYZAfter, double* dMeasXYZAfter, double* dDeviationAfter, double* dIJKAfter);
};
/////////////////////////////////////////////////////////////////////////////
// IPoint wrapper class

class IPoint : public COleDispatchDriver
{
public:
	IPoint() {}		// Calls COleDispatchDriver default constructor
	IPoint(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IPoint(const IPoint& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	double GetX();
	void SetX(double);
	double GetY();
	void SetY(double);
	double GetZ();
	void SetZ(double);
	double GetI();
	void SetI(double);
	double GetJ();
	void SetJ(double);
	double GetK();
	void SetK(double);

// Operations
public:
	void XYZ(double X, double Y, double Z);
	void IJK(double I, double J, double K);
};
/////////////////////////////////////////////////////////////////////////////
// IDmisMatrix wrapper class

class IDmisMatrix : public COleDispatchDriver
{
public:
	IDmisMatrix() {}		// Calls COleDispatchDriver default constructor
	IDmisMatrix(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IDmisMatrix(const IDmisMatrix& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetPrimaryAxis();
	void SetPrimaryAxis(LPDISPATCH);
	LPDISPATCH GetSecondaryAxis();
	void SetSecondaryAxis(LPDISPATCH);
	LPDISPATCH GetTertiaryAxis();
	void SetTertiaryAxis(LPDISPATCH);
	LPDISPATCH GetOffset();
	void SetOffset(LPDISPATCH);
	BOOL GetIsIdentity();
	void SetIsIdentity(BOOL);
	LPDISPATCH GetCopy();
	void SetCopy(LPDISPATCH);
	LPDISPATCH GetInverse();
	void SetInverse(LPDISPATCH);
	LPDISPATCH Get_Copy();
	void Set_Copy(LPDISPATCH);

// Operations
public:
	void Reset();
	void Normalize();
	void SetMatrix(LPDISPATCH Vector, LPDISPATCH Point, long Workplane);
	void RotateByAngle(double Angle, long Workplane);
	void RotateToPoint(double X, double Y, long Workplane);
	void RotateToVector(LPDISPATCH Vector, long Workplane);
	void TransformDataBack(LPDISPATCH* PointData, long TransformationType, long Workplane);
	void TransformDataForward(LPDISPATCH* PointData, long TransformationType, long Workplane);
	double Item(long Num);
	LPDISPATCH Multiply(LPDISPATCH SecondMatrix);
};
/////////////////////////////////////////////////////////////////////////////
// IDimensionCmd wrapper class

class IDimensionCmd : public COleDispatchDriver
{
public:
	IDimensionCmd() {}		// Calls COleDispatchDriver default constructor
	IDimensionCmd(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IDimensionCmd(const IDimensionCmd& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	double GetAngle();
	void SetAngle(double);
	double GetBonus();
	void SetBonus(double);
	double GetDeviation();
	void SetDeviation(double);
	double GetDevAngle();
	void SetDevAngle(double);
	CString GetId();
	void SetId(LPCTSTR);
	CString GetFeat1();
	void SetFeat1(LPCTSTR);
	CString GetFeat2();
	void SetFeat2(LPCTSTR);
	CString GetFeat3();
	void SetFeat3(LPCTSTR);
	double GetLength();
	void SetLength(double);
	double GetNominal();
	void SetNominal(double);
	double GetMax();
	void SetMax(double);
	double GetMeasured();
	void SetMeasured(double);
	double GetMin();
	void SetMin(double);
	double GetMinus();
	void SetMinus(double);
	double GetPlus();
	void SetPlus(double);
	double GetOutTol();
	void SetOutTol(double);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetAxis();
	void SetAxis(long);
	BOOL GetGraphicalAnalysis();
	void SetGraphicalAnalysis(BOOL);
	BOOL GetTextualAnalysis();
	void SetTextualAnalysis(BOOL);
	double GetArrowMultiplier();
	void SetArrowMultiplier(double);
	long GetOutputMode();
	void SetOutputMode(long);
	long GetParallelPerpendicular();
	void SetParallelPerpendicular(long);
	long GetRadiusType();
	void SetRadiusType(long);
	long GetUnits();
	void SetUnits(long);
	long GetProfile();
	void SetProfile(long);
	long GetTruePositionModifier();
	void SetTruePositionModifier(long);
	long GetTruePosUseAxis();
	void SetTruePosUseAxis(long);
	CString GetAxisLetter();
	void SetAxisLetter(LPCTSTR);
	BOOL GetIsLocationAxis();
	void SetIsLocationAxis(BOOL);
	BOOL GetIsTruePosAxis();
	void SetIsTruePosAxis(BOOL);
	CString GetDatum1();
	void SetDatum1(LPCTSTR);
	CString GetDatum2();
	void SetDatum2(LPCTSTR);
	CString GetDatum3();
	void SetDatum3(LPCTSTR);
	long GetTruePositionDatumModifier();
	void SetTruePositionDatumModifier(long);
	long GetDimensionModifier();
	void SetDimensionModifier(long);
	long GetDatum1Modifier();
	void SetDatum1Modifier(long);
	long GetDatum2Modifier();
	void SetDatum2Modifier(long);
	long GetDatum3Modifier();
	void SetDatum3Modifier(long);
	BOOL GetIsProfileDimension();
	void SetIsProfileDimension(BOOL);
	long GetProfilePointInfoCount();
	void SetProfilePointInfoCount(long);
	long GetAngle2DToFrom();
	void SetAngle2DToFrom(long);
	long GetAngle2DSupplemental();
	void SetAngle2DSupplemental(long);

// Operations
public:
	void Evaluate();
	void AddAxes();
	VARIANT GetProfilePointInfos(long InfoType, long CoordSystem, LPCTSTR Alignment);
};
/////////////////////////////////////////////////////////////////////////////
// IFeatCmd wrapper class

class IFeatCmd : public COleDispatchDriver
{
public:
	IFeatCmd() {}		// Calls COleDispatchDriver default constructor
	IFeatCmd(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IFeatCmd(const IFeatCmd& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	CString GetId();
	void SetId(LPCTSTR);
	long GetNumHits();
	void SetNumHits(long);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	double GetPermHits();
	void SetPermHits(double);
	double GetIndent();
	void SetIndent(double);
	double GetThickness();
	void SetThickness(double);
	double GetSpacer();
	void SetSpacer(double);
	double GetAutoMoveDistance();
	void SetAutoMoveDistance(double);
	BOOL GetInner();
	void SetInner(BOOL);
	BOOL GetUsePin();
	void SetUsePin(BOOL);
	BOOL GetAutoReadPos();
	void SetAutoReadPos(BOOL);
	BOOL GetAutoMove();
	void SetAutoMove(BOOL);
	BOOL GetFindHole();
	void SetFindHole(BOOL);
	double GetStartAngle();
	void SetStartAngle(double);
	double GetEndAngle();
	void SetEndAngle(double);
	double GetStartAngle2();
	void SetStartAngle2(double);
	double GetEndAngle2();
	void SetEndAngle2(double);
	double GetInitHits();
	void SetInitHits(double);
	double GetDepth();
	void SetDepth(double);
	double GetTheoDiam();
	void SetTheoDiam(double);
	double GetTheoLength();
	void SetTheoLength(double);
	double GetMeasDiam();
	void SetMeasDiam(double);
	double GetMeasLength();
	void SetMeasLength(double);
	double GetMeasPinDiam();
	void SetMeasPinDiam(double);
	double GetTheoPinDiam();
	void SetTheoPinDiam(double);
	CString GetRMeasFeature();
	void SetRMeasFeature(LPCTSTR);
	double GetIndent2();
	void SetIndent2(double);
	double GetMeasAngle();
	void SetMeasAngle(double);
	double GetTheoAngle();
	void SetTheoAngle(double);
	double GetMeasSmallLength();
	void SetMeasSmallLength(double);
	double GetTheoSmallLength();
	void SetTheoSmallLength(double);
	long GetNumRows();
	void SetNumRows(long);
	long GetNumHitsPerRow();
	void SetNumHitsPerRow(long);
	long GetEdgeMeasureOrder();
	void SetEdgeMeasureOrder(long);
	double GetEdgeThickness();
	void SetEdgeThickness(double);
	double GetIndent3();
	void SetIndent3(double);
	double GetTheoMajorAxis();
	void SetTheoMajorAxis(double);
	double GetTheoMinorAxis();
	void SetTheoMinorAxis(double);
	double GetMeasMajorAxis();
	void SetMeasMajorAxis(double);
	double GetMeasMinorAxis();
	void SetMeasMinorAxis(double);
	long GetHighPointSearchMode();
	void SetHighPointSearchMode(long);
	double GetIncrement();
	void SetIncrement(double);
	double GetTolerance();
	void SetTolerance(double);
	double GetBoxWidth();
	void SetBoxWidth(double);
	double GetBoxLength();
	void SetBoxLength(double);
	double GetCircularRadiusOut();
	void SetCircularRadiusOut(double);
	double GetCircularRadiusIn();
	void SetCircularRadiusIn(double);
	double GetCornerRadius();
	void SetCornerRadius(double);
	double GetTheoHeight();
	void SetTheoHeight(double);
	double GetMeasHeight();
	void SetMeasHeight(double);
	double GetDeviation();
	void SetDeviation(double);
	BOOL GetMeasureSlotWidth();
	void SetMeasureSlotWidth(BOOL);
	long GetAlignWorkPlane();
	void SetAlignWorkPlane(long);
	long GetGenericType();
	void SetGenericType(long);
	long GetGenericDisplayMode();
	void SetGenericDisplayMode(long);
	long GetGenericAlignMode();
	void SetGenericAlignMode(long);
	long GetFilterType();
	void SetFilterType(long);
	BOOL GetPolar();
	void SetPolar(BOOL);
	BOOL GetBound();
	void SetBound(BOOL);
	BOOL GetDisplayConeAngle();
	void SetDisplayConeAngle(BOOL);
	BOOL GetLine3D();
	void SetLine3D(BOOL);
	BOOL GetDCCMeasureInMasterMode();
	void SetDCCMeasureInMasterMode(BOOL);
	BOOL GetDCCFindNomsMode();
	void SetDCCFindNomsMode(BOOL);
	BOOL GetInteriorHit();
	void SetInteriorHit(BOOL);
	BOOL GetAutoPH9();
	void SetAutoPH9(BOOL);
	BOOL GetAutoClearPlane();
	void SetAutoClearPlane(BOOL);
	BOOL GetAutoCircularMove();
	void SetAutoCircularMove(BOOL);
	long GetReferenceType();
	void SetReferenceType(long);
	CString GetReferenceID();
	void SetReferenceID(LPCTSTR);
	long GetBestFitMathType();
	void SetBestFitMathType(long);
	BOOL GetUseTheoValuesForBestfit();
	void SetUseTheoValuesForBestfit(BOOL);
	double GetVisionMag();
	void SetVisionMag(double);
	long GetVisionTargetColor();
	void SetVisionTargetColor(long);
	BOOL GetManualPrePosition();
	void SetManualPrePosition(BOOL);
	long GetVisionTargetType();
	void SetVisionTargetType(long);
	LPDISPATCH GetTargets();
	void SetTargets(LPDISPATCH);
	BOOL GetHasUserDefinedHits();
	void SetHasUserDefinedHits(BOOL);

// Operations
public:
	BOOL GenerateHits();
	BOOL GetData(LPDISPATCH* PointData, long DataType, long TheoMeas, long CoordSystem, LPCTSTR AlignID, long Workplane);
	BOOL PutData(LPDISPATCH* Data, long DataType, long TheoMeas, long CoordSystem, LPCTSTR AlignID, long Workplane);
	BOOL SetInputFeat(LPCTSTR ID, long index);
	BOOL RemoveInputFeat(long index);
	BOOL AddInputFeat(LPCTSTR ID);
	CString GetInputID(long index);
	LPDISPATCH GetHit(long index, long DataType, long MeasOrTheo, long CoordSystem, LPCTSTR Alignment, long Workplane);
	BOOL GetVector(long VectorType, long TheoMeas, double* I, double* J, double* K);
	BOOL GetPoint(long PointType, long TheoMeas, double* X, double* Y, double* Z);
	BOOL PutVector(long VectorType, long TheoMeas, double I, double J, double K);
	BOOL PutPoint(long PointType, long TheoMeas, double X, double Y, double Z);
	BOOL GetSurfaceVectors(long TheoMeas, double* I1, double* J1, double* K1, double* I2, double* J2, double* K2);
	BOOL PutSurfaceVectors(long TheoMeas, double I1, double J1, double K1, double I2, double J2, double K2);
	double GetInputOffset(long index);
	BOOL SetInputOffset(long index, double Offset);
	BOOL CalculateNominals();
	BOOL CountHits();
	BOOL SetHit(long index, long DataType, long MeasOrTheo, double X, double Y, double Z);
	BOOL SetHit2(long index, long DataType, long MeasOrTheo, long CoordSystem, LPCTSTR Alignment, long Workplane, double X, double Y, double Z);
	BOOL Evaluate(long MeasNominal);
	LPDISPATCH GetSampleHit(long index, long DataType, long MeasOrTheo, long CoordSystem, LPCTSTR Alignment, long Workplane);
	LPDISPATCH GetCircMoveItem(long CircMove_Index, long Move_index, long CoordSystem, LPCTSTR Alignment, long Workplane);
	double GetFormError();
	VARIANT GetPoints(long DataType, long MeasOrTheo, long CoordSystem, LPCTSTR Alignment, long Workplane);
	long AddInputFeatures(const VARIANT& IDs);
};
/////////////////////////////////////////////////////////////////////////////
// ITargets wrapper class

class ITargets : public COleDispatchDriver
{
public:
	ITargets() {}		// Calls COleDispatchDriver default constructor
	ITargets(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ITargets(const ITargets& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetCount();
	void SetCount(long);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);

// Operations
public:
	LPDISPATCH Item(long Num);
	void Remove(long Num);
	void Add(double a, double b);
	LPDISPATCH _Item(long Num);
};
/////////////////////////////////////////////////////////////////////////////
// ITarget wrapper class

class ITarget : public COleDispatchDriver
{
public:
	ITarget() {}		// Calls COleDispatchDriver default constructor
	ITarget(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ITarget(const ITarget& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetStrength();
	void SetStrength(long);
	long GetEdgeSelectionType();
	void SetEdgeSelectionType(long);
	long GetFocus();
	void SetFocus(long);
	long GetFocusRange();
	void SetFocusRange(long);
	long GetFocusDuration();
	void SetFocusDuration(long);
	long GetFocusHiAccuracy();
	void SetFocusHiAccuracy(long);
	long GetPointDensityType();
	void SetPointDensityType(long);
	long GetEdgeSelectionSpecifiedNum();
	void SetEdgeSelectionSpecifiedNum(long);
	long GetEdgeScanDirection();
	void SetEdgeScanDirection(long);
	double GetCrossHairSize();
	void SetCrossHairSize(double);
	long GetOutlierFilter();
	void SetOutlierFilter(long);
	double GetOutlierFilterDistanceThreshold();
	void SetOutlierFilterDistanceThreshold(double);
	double GetOutlierFilterStdDevThreshold();
	void SetOutlierFilterStdDevThreshold(double);
	long GetOutlierFilterUsingNeighbors();
	void SetOutlierFilterUsingNeighbors(long);
	long GetOutlierFilterMinNeighbors();
	void SetOutlierFilterMinNeighbors(long);
	double GetOutlierFilterNeighborDistanceMultiplier();
	void SetOutlierFilterNeighborDistanceMultiplier(double);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IModalCmd wrapper class

class IModalCmd : public COleDispatchDriver
{
public:
	IModalCmd() {}		// Calls COleDispatchDriver default constructor
	IModalCmd(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IModalCmd(const IModalCmd& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetClearPlane();
	void SetClearPlane(long);
	long GetDigits();
	void SetDigits(long);
	double GetDistance();
	void SetDistance(double);
	double GetDistance2();
	void SetDistance2(double);
	BOOL GetOn();
	void SetOn(BOOL);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetPassPlane();
	void SetPassPlane(long);
	double GetSpeed();
	void SetSpeed(double);
	long GetWorkplane();
	void SetWorkplane(long);
	CString GetName();
	void SetName(LPCTSTR);
	long GetManDCCMode();
	void SetManDCCMode(long);
	long GetRMeasMode();
	void SetRMeasMode(long);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IMoveCmd wrapper class

class IMoveCmd : public COleDispatchDriver
{
public:
	IMoveCmd() {}		// Calls COleDispatchDriver default constructor
	IMoveCmd(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IMoveCmd(const IMoveCmd& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	double GetAngle();
	void SetAngle(double);
	long GetDirection();
	void SetDirection(long);
	LPDISPATCH GetXyz();
	void SetXyz(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	CString GetOldTip();
	void SetOldTip(LPCTSTR);
	CString GetNewTip();
	void SetNewTip(LPCTSTR);
	LPDISPATCH GetIjk();
	void SetIjk(LPDISPATCH);
	LPDISPATCH GetXYZStart();
	void SetXYZStart(LPDISPATCH);
	LPDISPATCH GetXYZEnd();
	void SetXYZEnd(LPDISPATCH);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IFlowControlCmd wrapper class

class IFlowControlCmd : public COleDispatchDriver
{
public:
	IFlowControlCmd() {}		// Calls COleDispatchDriver default constructor
	IFlowControlCmd(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IFlowControlCmd(const IFlowControlCmd& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	double GetAngleOffset();
	void SetAngleOffset(double);
	long GetEndNum();
	void SetEndNum(long);
	long GetErrorMode();
	void SetErrorMode(long);
	long GetErrorType();
	void SetErrorType(long);
	CString GetFilename();
	void SetFilename(LPCTSTR);
	CString GetId();
	void SetId(LPCTSTR);
	CString GetLabel();
	void SetLabel(LPCTSTR);
	long GetNumArguments();
	void SetNumArguments(long);
	long GetSkipCount();
	void SetSkipCount(long);
	long GetStartNum();
	void SetStartNum(long);
	CString GetSubName();
	void SetSubName(LPCTSTR);
	double GetXAxisOffset();
	void SetXAxisOffset(double);
	double GetYAxisOffset();
	void SetYAxisOffset(double);
	double GetZAxisOffset();
	void SetZAxisOffset(double);
	CString GetExpression();
	void SetExpression(LPCTSTR);
	BOOL GetReportAutoPrint();
	void SetReportAutoPrint(BOOL);

// Operations
public:
	BOOL AddArgument(long Position, LPCTSTR Argument, LPCTSTR Name, LPCTSTR DESCRIPTION);
	BOOL AddSkipNum(long Number);
	CString GetArgumentName(long Position);
	BOOL SetArgumentName(long Position, LPCTSTR Name);
	CString GetArgumentDescription(long Position);
	BOOL SetArgumentDescription(long Position, LPCTSTR DESCRIPTION);
	CString GetArgumentExpression(long Position);
	BOOL SetArgumentExpression(long Position, LPCTSTR Expression);
	BOOL IsExpressionValid(LPCTSTR Expression);
	BOOL RemoveArgument(long Position);
	long GetSkipNum(long index);
	BOOL RemoveSkipNum(long index);
	void SetRightSideOfAssignment(LPCTSTR Expression);
	void SetLeftSideOfAssignment(LPCTSTR Expression);
	BOOL IsValidLeftHandValue(LPCTSTR Expression);
	BOOL IsValidSubroutineArgumentName(LPCTSTR Expression);
	CString GetLeftSideOfExpression();
	CString GetRightSideOfExpression();
};
/////////////////////////////////////////////////////////////////////////////
// IBasicScan wrapper class

class IBasicScan : public COleDispatchDriver
{
public:
	IBasicScan() {}		// Calls COleDispatchDriver default constructor
	IBasicScan(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IBasicScan(const IBasicScan& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetMethod();
	void SetMethod(long);
	long GetFilter();
	void SetFilter(long);
	long GetOperationMode();
	void SetOperationMode(long);
	long GetHitType();
	void SetHitType(long);
	long GetNominalMode();
	void SetNominalMode(long);
	long GetBoundaryCondition();
	void SetBoundaryCondition(long);
	LPDISPATCH GetMethodStart();
	void SetMethodStart(LPDISPATCH);
	LPDISPATCH GetMethodEnd();
	void SetMethodEnd(LPDISPATCH);
	LPDISPATCH GetMethodInitTouch();
	void SetMethodInitTouch(LPDISPATCH);
	LPDISPATCH GetMethodEndTouch();
	void SetMethodEndTouch(LPDISPATCH);
	LPDISPATCH GetMethodInitDir();
	void SetMethodInitDir(LPDISPATCH);
	LPDISPATCH GetMethodInitTopSurf();
	void SetMethodInitTopSurf(LPDISPATCH);
	LPDISPATCH GetMethodCutPlane();
	void SetMethodCutPlane(LPDISPATCH);
	LPDISPATCH GetBoundaryConditionCenter();
	void SetBoundaryConditionCenter(LPDISPATCH);
	LPDISPATCH GetBoundaryConditionPlaneV();
	void SetBoundaryConditionPlaneV(LPDISPATCH);
	LPDISPATCH GetBoundaryConditionAxisV();
	void SetBoundaryConditionAxisV(LPDISPATCH);
	LPDISPATCH GetBoundaryConditionEndApproach();
	void SetBoundaryConditionEndApproach(LPDISPATCH);
	BOOL GetSinglePoint();
	void SetSinglePoint(BOOL);
	BOOL GetAutoClearPlane();
	void SetAutoClearPlane(BOOL);
	BOOL GetDisplayHits();
	void SetDisplayHits(BOOL);
	long GetBoundaryPointCount();
	void SetBoundaryPointCount(long);

// Operations
public:
	BOOL SetMethodParams(long bIn, BOOL bCenteringType, long nCenteringDirection, double dDiameter, double dArcAngle, double dDepth, double dPitch);
	BOOL GetMethodParams(long* bIn, BOOL* bCenteringType, long* nCenteringDirection, double* dDiameter, double* dArcAngle, double* dDepth, double* dPitch);
	BOOL GetBoundaryConditionParams(long* nCrossings, double* dRadius, double* dHalfAngle);
	BOOL SetBoundaryConditionParams(long nCrossings, double dRadius, double dHalfAngle);
	BOOL SetNomsParams(double dFindNomsTolerance, double dSurfaceThickness, double dEdgeThickness);
	BOOL GetNomsParams(double* dFindNomsTolerance, double* dSurfaceThickness, double* dEdgeThickness);
	BOOL SetFilterParams(double dCutAxisLocation, long nAxis, double dMaxIncrement, double dMinIncrement, double dMaxAngle, double dMinAngle);
	BOOL SetHitParams(long nInitSamples, long nPermSamples, double dSpacer, double dIndent, double dDepth);
	BOOL GetHitParams(long* nInitSamples, long* nPermSamples, double* dSpacer, double* dIndent, double* dDepth);
	BOOL GetFilterParams(double* dCutAxisLocation, long* nAxis, double* dMaxIncrement, double* dMinIncrement, double* dMaxAngle, double* dMinAngle);
	BOOL SetParams(long Method, long Filter, long OperationMode, long HitType, long NominalMode, long BoundaryCondition);
	BOOL GetParams(long* Method, long* Filter, long* OperationMode, long* HitType, long* NominalMode, long* BoundaryCondition);
	BOOL SetMethodPointData(LPDISPATCH MethodStart, LPDISPATCH MethodEnd, LPDISPATCH MethodInitTouch, LPDISPATCH MethodEndTouch, LPDISPATCH MethodInitDir, LPDISPATCH MethodInitTopSurf, LPDISPATCH MethodCutPlane);
	BOOL GetMethodPointData(LPDISPATCH MethodStart, LPDISPATCH MethodEnd, LPDISPATCH MethodInitTouch, LPDISPATCH MethodEndTouch, LPDISPATCH MethodInitDir, LPDISPATCH MethodInitTopSurf, LPDISPATCH MethodCutPlane);
	BOOL CreateBasicScan();
	BOOL GetBoundaryPoint(long index, double* X, double* Y, double* Z);
	BOOL SetBoundaryPoint(long index, double X, double Y, double Z);
	BOOL AddControlPoint(LPDISPATCH ControlPoint);
	LPDISPATCH GetControlPoint(long index);
	BOOL SetControlPoint(long index, LPDISPATCH ControlPoint);
	BOOL RemoveControlPoint(long index);
	BOOL GetHitTValue(long index, double* T);
	BOOL GenerateScan();
};
/////////////////////////////////////////////////////////////////////////////
// IControlPoint wrapper class

class IControlPoint : public COleDispatchDriver
{
public:
	IControlPoint() {}		// Calls COleDispatchDriver default constructor
	IControlPoint(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IControlPoint(const IControlPoint& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	double GetX();
	void SetX(double);
	double GetY();
	void SetY(double);
	double GetZ();
	void SetZ(double);
	double GetI();
	void SetI(double);
	double GetJ();
	void SetJ(double);
	double GetK();
	void SetK(double);
	long GetType();
	void SetType(long);
	double GetRadius();
	void SetRadius(double);
	double GetSpeed();
	void SetSpeed(double);
	long GetPointDensity();
	void SetPointDensity(long);
	long GetCrossings();
	void SetCrossings(long);
	double GetPointDensity2();
	void SetPointDensity2(double);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// ICalibration wrapper class

class ICalibration : public COleDispatchDriver
{
public:
	ICalibration() {}		// Calls COleDispatchDriver default constructor
	ICalibration(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ICalibration(const ICalibration& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	CString GetSphereID();
	void SetSphereID(LPCTSTR);
	CString GetToolID();
	void SetToolID(LPCTSTR);
	BOOL GetMoved();
	void SetMoved(BOOL);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IAttach wrapper class

class IAttach : public COleDispatchDriver
{
public:
	IAttach() {}		// Calls COleDispatchDriver default constructor
	IAttach(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IAttach(const IAttach& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	CString GetId();
	void SetId(LPCTSTR);
	CString GetPartName();
	void SetPartName(LPCTSTR);
	BOOL GetExecute();
	void SetExecute(BOOL);
	CString GetLocalAlign();
	void SetLocalAlign(LPCTSTR);
	CString GetAttachedAlign();
	void SetAttachedAlign(LPCTSTR);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IExtCmd wrapper class

class IExtCmd : public COleDispatchDriver
{
public:
	IExtCmd() {}		// Calls COleDispatchDriver default constructor
	IExtCmd(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IExtCmd(const IExtCmd& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	CString GetCommand();
	void SetCommand(LPCTSTR);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IOptionProbe wrapper class

class IOptionProbe : public COleDispatchDriver
{
public:
	IOptionProbe() {}		// Calls COleDispatchDriver default constructor
	IOptionProbe(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IOptionProbe(const IOptionProbe& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	double GetMaxForce();
	void SetMaxForce(double);
	double GetLowForce();
	void SetLowForce(double);
	double GetUpperForce();
	void SetUpperForce(double);
	double GetTriggerForce();
	void SetTriggerForce(double);
	double GetProbeAccuracy();
	void SetProbeAccuracy(double);
	double GetPositionalAccuracy();
	void SetPositionalAccuracy(double);
	double GetReturnData();
	void SetReturnData(double);
	double GetReturnSpeed();
	void SetReturnSpeed(double);
	double GetScanPointDensity();
	void SetScanPointDensity(double);
	double GetScanAcceleration();
	void SetScanAcceleration(double);
	double GetScanOffsetForce();
	void SetScanOffsetForce(double);
	CString GetProbingMode();
	void SetProbingMode(LPCTSTR);
	long GetManFineProbing();
	void SetManFineProbing(long);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// ILeapfrog wrapper class

class ILeapfrog : public COleDispatchDriver
{
public:
	ILeapfrog() {}		// Calls COleDispatchDriver default constructor
	ILeapfrog(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ILeapfrog(const ILeapfrog& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	short GetLeapfrogtype();
	void SetLeapfrogtype(short);
	short GetNumHits();
	void SetNumHits(short);
	long GetFull();
	void SetFull(long);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IOptMotion wrapper class

class IOptMotion : public COleDispatchDriver
{
public:
	IOptMotion() {}		// Calls COleDispatchDriver default constructor
	IOptMotion(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IOptMotion(const IOptMotion& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	double GetMaxXAcceleration();
	void SetMaxXAcceleration(double);
	double GetMaxYAcceleration();
	void SetMaxYAcceleration(double);
	double GetMaxZAcceleration();
	void SetMaxZAcceleration(double);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IArrayIndex wrapper class

class IArrayIndex : public COleDispatchDriver
{
public:
	IArrayIndex() {}		// Calls COleDispatchDriver default constructor
	IArrayIndex(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IArrayIndex(const IArrayIndex& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	BOOL AddIndexSet(long LowerBound, long UpperBound);
	BOOL SetUpperBound(long index, long UpperBound);
	BOOL SetLowerBound(long index, long LowerBound);
	BOOL RemoveIndexSet(long index);
	long GetLowerBound(long index);
	long GetUpperBound(long index);
};
/////////////////////////////////////////////////////////////////////////////
// IFileIO wrapper class

class IFileIO : public COleDispatchDriver
{
public:
	IFileIO() {}		// Calls COleDispatchDriver default constructor
	IFileIO(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IFileIO(const IFileIO& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetFileIOType();
	void SetFileIOType(long);
	long GetFileOpenType();
	void SetFileOpenType(long);
	CString GetFilePointerID();
	void SetFilePointerID(LPCTSTR);
	CString GetExpression();
	void SetExpression(LPCTSTR);
	CString GetVariableID();
	void SetVariableID(LPCTSTR);
	long GetBufferSize();
	void SetBufferSize(long);
	CString GetFileName1();
	void SetFileName1(LPCTSTR);
	CString GetFileName2();
	void SetFileName2(LPCTSTR);
	BOOL GetFailIfExists();
	void SetFailIfExists(BOOL);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// ITempComp wrapper class

class ITempComp : public COleDispatchDriver
{
public:
	ITempComp() {}		// Calls COleDispatchDriver default constructor
	ITempComp(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ITempComp(const ITempComp& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	double GetMaterialCoefficient();
	void SetMaterialCoefficient(double);
	double GetRefTemp();
	void SetRefTemp(double);
	double GetHighThreshold();
	void SetHighThreshold(double);
	double GetLowTheshold();
	void SetLowTheshold(double);
	CString GetSensors();
	void SetSensors(LPCTSTR);

// Operations
public:
	BOOL SetOrigin(double X, double Y, double Z);
	BOOL GetOrigin(double* X, double* Y, double* Z);
};
/////////////////////////////////////////////////////////////////////////////
// IDispMetaFile wrapper class

class IDispMetaFile : public COleDispatchDriver
{
public:
	IDispMetaFile() {}		// Calls COleDispatchDriver default constructor
	IDispMetaFile(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IDispMetaFile(const IDispMetaFile& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	CString GetComment();
	void SetComment(LPCTSTR);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IComment wrapper class

class IComment : public COleDispatchDriver
{
public:
	IComment() {}		// Calls COleDispatchDriver default constructor
	IComment(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IComment(const IComment& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetCommentType();
	void SetCommentType(long);
	CString GetId();
	void SetId(LPCTSTR);
	CString GetComment();
	void SetComment(LPCTSTR);
	CString GetInput();
	void SetInput(LPCTSTR);

// Operations
public:
	CString GetLine(long Line);
	BOOL SetLine(long Line, LPCTSTR Text);
	BOOL AddLine(LPCTSTR Text);
	BOOL RemoveLine(long Line);
};
/////////////////////////////////////////////////////////////////////////////
// IStatistics wrapper class

class IStatistics : public COleDispatchDriver
{
public:
	IStatistics() {}		// Calls COleDispatchDriver default constructor
	IStatistics(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IStatistics(const IStatistics& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetStatMode();
	void SetStatMode(long);
	long GetReadLock();
	void SetReadLock(long);
	long GetWriteLock();
	void SetWriteLock(long);
	long GetMemoryPages();
	void SetMemoryPages(long);
	long GetNameType();
	void SetNameType(long);
	long GetCalcMode();
	void SetCalcMode(long);
	CString GetTransferDir();
	void SetTransferDir(LPCTSTR);

// Operations
public:
	BOOL AddStatsDir(LPCTSTR Dir);
	CString GetStatsDir(long index);
	BOOL SetStatsDir(long index, LPCTSTR Dir);
	BOOL RemoveStatsDir(long index);
};
/////////////////////////////////////////////////////////////////////////////
// ITraceField wrapper class

class ITraceField : public COleDispatchDriver
{
public:
	ITraceField() {}		// Calls COleDispatchDriver default constructor
	ITraceField(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ITraceField(const ITraceField& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	CString GetName();
	void SetName(LPCTSTR);
	CString GetValue();
	void SetValue(LPCTSTR);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IActiveTip wrapper class

class IActiveTip : public COleDispatchDriver
{
public:
	IActiveTip() {}		// Calls COleDispatchDriver default constructor
	IActiveTip(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IActiveTip(const IActiveTip& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	CString GetTipID();
	void SetTipID(LPCTSTR);
	double GetAngle();
	void SetAngle(double);

// Operations
public:
	BOOL GetShankVector(double* I, double* J, double* K);
	BOOL SetShankVector(double I, double J, double K);
	LPDISPATCH GenCalSphereHits(LPDISPATCH CENTER_POINT, LPDISPATCH center_vector, double diameter, long total_hits, long num_rows, double start_angle1, double end_angle1, double start_angle2, double end_angle2, LPDISPATCH circle_vector);
	void SetCalSphereData(double X, double Y, double Z, double I, double J, double K, double diam);
	void SetCalData(long totalHits, long NumRows, double startAngle1, double endAngle1, double StartAngle2, double EndAngle2);
	void SetCalCircleVector(double I, double J, double K);
	void GetHits(long Num, double* hitbuffer);
	long genHitsInfo();
};
/////////////////////////////////////////////////////////////////////////////
// ILoadProbe wrapper class

class ILoadProbe : public COleDispatchDriver
{
public:
	ILoadProbe() {}		// Calls COleDispatchDriver default constructor
	ILoadProbe(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ILoadProbe(const ILoadProbe& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	CString GetFilename();
	void SetFilename(LPCTSTR);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IDimFormat wrapper class

class IDimFormat : public COleDispatchDriver
{
public:
	IDimFormat() {}		// Calls COleDispatchDriver default constructor
	IDimFormat(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IDimFormat(const IDimFormat& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	BOOL GetShowHeadings();
	void SetShowHeadings(BOOL);
	BOOL GetShowDevSymbols();
	void SetShowDevSymbols(BOOL);
	BOOL GetShowStdDev();
	void SetShowStdDev(BOOL);
	BOOL GetShowDimensionText();
	void SetShowDimensionText(BOOL);
	BOOL GetShowDimensionTextOptions();
	void SetShowDimensionTextOptions(BOOL);

// Operations
public:
	long GetHeadingType(long index);
	BOOL SetHeadingType(long index, long HeadingType);
};
/////////////////////////////////////////////////////////////////////////////
// IDimInfo wrapper class

class IDimInfo : public COleDispatchDriver
{
public:
	IDimInfo() {}		// Calls COleDispatchDriver default constructor
	IDimInfo(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IDimInfo(const IDimInfo& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	CString GetDimensionId();
	void SetDimensionId(LPCTSTR);
	BOOL GetShowDimId();
	void SetShowDimId(BOOL);
	BOOL GetShowFeatId();
	void SetShowFeatId(BOOL);

// Operations
public:
	long GetFieldFormat(long index);
	BOOL SetFieldFormat(long index, long FieldType);
	long GetLocationAxis(long index);
	BOOL SetLocationAxis(long index, long AXIS);
	long GetTruePosAxis(long index);
	BOOL SetTruePosAxis(long index, long AXIS);
};
/////////////////////////////////////////////////////////////////////////////
// ILoadMachine wrapper class

class ILoadMachine : public COleDispatchDriver
{
public:
	ILoadMachine() {}		// Calls COleDispatchDriver default constructor
	ILoadMachine(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ILoadMachine(const ILoadMachine& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	CString GetMachineName();
	void SetMachineName(LPCTSTR);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IDataTypes wrapper class

class IDataTypes : public COleDispatchDriver
{
public:
	IDataTypes() {}		// Calls COleDispatchDriver default constructor
	IDataTypes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IDataTypes(const IDataTypes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetCount();
	void SetCount(long);

// Operations
public:
	LPDISPATCH Item(long Num);
	LPDISPATCH GetDataTypeInfo(long DataType);
	LPDISPATCH _Item(long Identifier);
};
/////////////////////////////////////////////////////////////////////////////
// IDataType wrapper class

class IDataType : public COleDispatchDriver
{
public:
	IDataType() {}		// Calls COleDispatchDriver default constructor
	IDataType(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IDataType(const IDataType& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetCount();
	void SetCount(long);
	long GetValue();
	void SetValue(long);
	CString GetDescription();
	void SetDescription(LPCTSTR);
	long GetType();
	void SetType(long);
	long GetDBType();
	void SetDBType(long);
	long GetVariableType();
	void SetVariableType(long);
	// property '_Value' not emitted because of invalid type

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IToolkitInternalCommands wrapper class

class IToolkitInternalCommands : public COleDispatchDriver
{
public:
	IToolkitInternalCommands() {}		// Calls COleDispatchDriver default constructor
	IToolkitInternalCommands(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IToolkitInternalCommands(const IToolkitInternalCommands& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetCount();
	void SetCount(long);

// Operations
public:
	LPDISPATCH Item(const VARIANT& NameorNum);
	LPDISPATCH _Item(const VARIANT& NameorNum);
};
/////////////////////////////////////////////////////////////////////////////
// IStrategies wrapper class

class IStrategies : public COleDispatchDriver
{
public:
	IStrategies() {}		// Calls COleDispatchDriver default constructor
	IStrategies(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IStrategies(const IStrategies& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetCount();
	void SetCount(long);
	LPDISPATCH GetCurrentStrategy();
	void SetCurrentStrategy(LPDISPATCH);

// Operations
public:
	LPDISPATCH Item(const VARIANT& IndexOrName);
	BOOL SetCurrentStrategy(const VARIANT& IndexOrName);
};
/////////////////////////////////////////////////////////////////////////////
// IStrategy wrapper class

class IStrategy : public COleDispatchDriver
{
public:
	IStrategy() {}		// Calls COleDispatchDriver default constructor
	IStrategy(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IStrategy(const IStrategy& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	CString GetName();
	void SetName(LPCTSTR);
	BOOL GetIsDefaultStrategy();
	void SetIsDefaultStrategy(BOOL);
	long GetIndex();
	void SetIndex(long);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IDialog wrapper class

class IDialog : public COleDispatchDriver
{
public:
	IDialog() {}		// Calls COleDispatchDriver default constructor
	IDialog(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IDialog(const IDialog& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	BOOL GetVisible();
	void SetVisible(BOOL);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IVariable wrapper class

class IVariable : public COleDispatchDriver
{
public:
	IVariable() {}		// Calls COleDispatchDriver default constructor
	IVariable(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IVariable(const IVariable& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetVariableType();
	void SetVariableType(long);
	long GetLongValue();
	void SetLongValue(long);
	double GetDoubleValue();
	void SetDoubleValue(double);
	CString GetStringValue();
	void SetStringValue(LPCTSTR);
	LPDISPATCH GetPointValue();
	void SetPointValue(LPDISPATCH);
	LPDISPATCH GetCommandValue();
	void SetCommandValue(LPDISPATCH);

// Operations
public:
	long GetArrayUpperBound();
	long GetArrayLowerBound();
	LPDISPATCH GetArrayIndexValue(long index);
	BOOL SetArrayIndexValue(long index, LPDISPATCH Variable);
};
/////////////////////////////////////////////////////////////////////////////
// IOldBasic wrapper class

class IOldBasic : public COleDispatchDriver
{
public:
	IOldBasic() {}		// Calls COleDispatchDriver default constructor
	IOldBasic(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IOldBasic(const IOldBasic& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);

// Operations
public:
	void AddBoundaryPoint(double X, double Y, double Z);
	void AddFeature(LPCTSTR ID, double off1, double off2, double off3);
	void AddLevelFeat(LPCTSTR ID);
	void AddOriginFeat(LPCTSTR ID);
	void AddRotateFeat(LPCTSTR ID);
	void BestFit2D(long num_inputs, long Workplane);
	void BestFit3D(long num_inputs);
	void Calibrate(LPCTSTR sphere, LPCTSTR tool, long Moved);
	void CatchMotionError(long tog, long* catch_error);
	void Check(double DISTANCE);
	void ClearPlane(long plane1, double val1, long plane2, double val2);
	void Column132(long tog);
	void Comment(long ctype, LPCTSTR Comment);
	void CreateID(BSTR* ID, long ftype);
	void DefaultAxes();
	void DefaultHits();
	void DimFormat(long flags, long heading1, long heading2, long heading3, long heading4, long heading5, long heading6);
	void EndAlign();
	void EndDim();
	void EndFeature();
	void EndGetFeatPoint();
	void EndScan();
	void EquateAlign(LPCTSTR align1, LPCTSTR align2);
	void Feature(LPCTSTR ID, double pnt_tol);
	void GapOnly(long tog);
	void Hit(double X, double Y, double Z, double I, double J, double K);
	void IgnoreMotionError(long tog);
	void Iterate(double pnt_tol, long flags);
	void Level(long AXIS, LPCTSTR feat);
	void LoadProbe(LPCTSTR probe);
	void Mode(long Mode);
	void Move(long tog, double X, double Y, double Z, long Direction);
	void MoveSpeed(double percent);
	void PreHit(double DISTANCE);
	void ProbeComp(long tog);
	void RecallEx(LPCTSTR recallID, LPCTSTR fname);
	void RecallIn(LPCTSTR recallID);
	void Retract(double DISTANCE);
	void RetroOnly(long tog);
	void Rotate(long axis1, LPCTSTR feat, long axis2);
	void RotateCircle(LPCTSTR Feat1, LPCTSTR Feat2, long axis1, long axis2);
	void RotateOffset(double Offset, long AXIS);
	void SaveAlign(LPCTSTR AlignID, LPCTSTR fname);
	void SetAutoParams(const VARIANT& INIT_HITS, const VARIANT& PERM_HITS, const VARIANT& Depth, const VARIANT& Height, const VARIANT& wdth, const VARIANT& Radius, const VARIANT& Spacer, const VARIANT& Indent, const VARIANT& Thickness, 
		const VARIANT& DISTANCE, const VARIANT& major, const VARIANT& minor);
	void SetAutoVector(long index, double I, double J, double K);
	void SetNoms(long dtype, const VARIANT& nom, const VARIANT& plus_tol, const VARIANT& minus_tol, const VARIANT& multiplier);
	void SetPrintOptions(long Location, long Draft, long Filemode, long ExtNum);
	void SetProgramOption(long opt, long tog);
	void SetProgramValue(long opt, double val);
	void SetReportOptions(long opt);
	void SetSlaveMode(long tog);
	void SetTheos(const VARIANT& X, const VARIANT& Y, const VARIANT& Z, const VARIANT& I, const VARIANT& J, const VARIANT& K, const VARIANT& diam, const VARIANT& Length, const VARIANT& Angle, const VARIANT& small_diam, const VARIANT& start_angle, 
		const VARIANT& end_angle, const VARIANT& start_angle2, const VARIANT& end_angle2);
	void SetRMeasMode(long Mode);
	void SetScanHitParams(long htype, long INIT_HITS, long PERM_HITS, double Spacer, double Depth, double Indent, long flags);
	void SetScanHitVectors(long Vector, long I, long J, long K);
	void SetScanParams(double incr, long AXIS, double max_incr, double min_incr, double MAX_ANGLE, double MIN_ANGLE, double delta, double DISTANCE, double incr2, long axis2, double surf_thickness);
	void SetScanVectors(long Vector, double I, double J, double K);
	void ShowXYZWindow(long show);
	void StartAlign(LPCTSTR ID, LPCTSTR recallID);
	void StartDim(long dtype, LPCTSTR ID, LPCTSTR Feat1, LPCTSTR Feat2, LPCTSTR Feat3, long AXIS, double Length, double Angle, long flags);
	void StartFeature(long ftype, LPCTSTR ID, LPCTSTR RefID, long hits, long rows, long inputs, long flags, long RefPlane);
	void StartScan(LPCTSTR ID, long Mode, long stype, long dir1, long dir2, long technique, long num_bnd_pnts, long flags);
	void Stats(long tog, LPCTSTR dbase_dir, long read_lock, long write_lock, long mem_page, long flags);
	void Tip(LPCTSTR Tip, double I, double J, double K, double Angle);
	void Touchspeed(double percent);
	void Trace(LPCTSTR field);
	void Translate(long AXIS, LPCTSTR feat);
	void TranslateOffset(double Offset, long AXIS);
	double ArcCos(double X);
	double ArcSin(double X);
	long CloseCommConnection(long port);
	long Flatness(LPCTSTR ID, double out_zone);
	long GetDimOutTol();
	long GetFeatID(long index, BSTR* ID, long Type);
	long GetFeature(LPCTSTR ID);
	long GetPH9Status();
	double GetProbeRadius();
	long GetProgramOption(long opt);
	double GetProgramValue(long opt);
	double GetTopMachineSpeed();
	long GetType(LPCTSTR ID);
	long GetUnits();
	long OpenCommConnection(long port, long baud, long parity, long Data, long stop, long flow);
	long ReadCommBlock(long port, BSTR* buffer, long Count);
	long Roundness(LPCTSTR ID, double* out_zone);
	long StartGetFeatPoint(LPCTSTR ID, long dtype, long XYZ);
	long Straitness(LPCTSTR ID, double* out_zone);
	long Workplane(long plane);
	long WriteCommBlock(long port, LPCTSTR buffer, long Count);
	void GetFeatData(LPCTSTR ID, LPDISPATCH buffer, long dtype, long XYZ, long IJK);
	void PutFeatData(LPCTSTR ID, LPDISPATCH* buffer, long dtype, long XYZ, long IJK);
	long GetFeatPoint(LPDISPATCH* buffer, long index);
	void GetProbeOffsets(LPDISPATCH* buffer);
	long MaxMinAve(LPCTSTR ID, LPDISPATCH* in_vect, double* out_max, double* out_min, double* out_ave);
	long RunOut(LPCTSTR ID, LPDISPATCH* in_datumxyz, LPDISPATCH* in_datumijk, double* out_zone);
	void GetDimData(LPCTSTR ID, LPDISPATCH* buffer, long dtype);
	void Wait();
	void Sleep(float seconds);
};
/////////////////////////////////////////////////////////////////////////////
// IFeatData wrapper class

class IFeatData : public COleDispatchDriver
{
public:
	IFeatData() {}		// Calls COleDispatchDriver default constructor
	IFeatData(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IFeatData(const IFeatData& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	double GetX();
	void SetX(double);
	double GetY();
	void SetY(double);
	double GetZ();
	void SetZ(double);
	double GetI();
	void SetI(double);
	double GetJ();
	void SetJ(double);
	double GetK();
	void SetK(double);
	double GetDiam();
	void SetDiam(double);
	double GetLength();
	void SetLength(double);
	double GetAngle();
	void SetAngle(double);
	double GetSmallDiam();
	void SetSmallDiam(double);
	double GetStartAngle();
	void SetStartAngle(double);
	double GetEndAngle();
	void SetEndAngle(double);
	double GetStartAngle2();
	void SetStartAngle2(double);
	double GetEndAngle2();
	void SetEndAngle2(double);
	double GetF();
	void SetF(double);
	double GetTp();
	void SetTp(double);
	double GetP1();
	void SetP1(double);
	double GetP2();
	void SetP2(double);
	CString GetId();
	void SetId(LPCTSTR);
	CString Get_id();
	void Set_id(LPCTSTR);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IDimData wrapper class

class IDimData : public COleDispatchDriver
{
public:
	IDimData() {}		// Calls COleDispatchDriver default constructor
	IDimData(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IDimData(const IDimData& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	double GetNom();
	void SetNom(double);
	double GetPlus();
	void SetPlus(double);
	double GetMinus();
	void SetMinus(double);
	double GetMax();
	void SetMax(double);
	double GetMin();
	void SetMin(double);
	double GetDev();
	void SetDev(double);
	double GetOut();
	void SetOut(double);
	double GetDevAngle();
	void SetDevAngle(double);
	double GetBonus();
	void SetBonus(double);
	double GetMeas();
	void SetMeas(double);
	double Get_Dev();
	void Set_Dev(double);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// ICadWindows wrapper class

class ICadWindows : public COleDispatchDriver
{
public:
	ICadWindows() {}		// Calls COleDispatchDriver default constructor
	ICadWindows(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ICadWindows(const ICadWindows& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetCount();
	void SetCount(long);

// Operations
public:
	LPDISPATCH Item(LPCTSTR ID);
	LPDISPATCH _Item(LPCTSTR ID);
};
/////////////////////////////////////////////////////////////////////////////
// ICadWindow wrapper class

class ICadWindow : public COleDispatchDriver
{
public:
	ICadWindow() {}		// Calls COleDispatchDriver default constructor
	ICadWindow(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ICadWindow(const ICadWindow& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	BOOL GetVisible();
	void SetVisible(BOOL);
	long GetLeft();
	void SetLeft(long);
	long GetWidth();
	void SetWidth(long);
	long GetTop();
	void SetTop(long);
	long GetHeight();
	void SetHeight(long);
	BOOL Get_Visible();
	void Set_Visible(BOOL);

// Operations
public:
	BOOL Print(long Option, BOOL DrawRulers);
};
/////////////////////////////////////////////////////////////////////////////
// ITools wrapper class

class ITools : public COleDispatchDriver
{
public:
	ITools() {}		// Calls COleDispatchDriver default constructor
	ITools(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ITools(const ITools& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetCount();
	void SetCount(long);

// Operations
public:
	LPDISPATCH Add(LPCTSTR ID);
	BOOL Remove(LPCTSTR ID);
	LPDISPATCH Item(const VARIANT& ID);
	LPDISPATCH _Item(const VARIANT& ID);
};
/////////////////////////////////////////////////////////////////////////////
// ITool wrapper class

class ITool : public COleDispatchDriver
{
public:
	ITool() {}		// Calls COleDispatchDriver default constructor
	ITool(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ITool(const ITool& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	double GetDiam();
	void SetDiam(double);
	CString GetId();
	void SetId(LPCTSTR);
	LPDISPATCH GetShankIJK();
	void SetShankIJK(LPDISPATCH);
	long GetToolType();
	void SetToolType(long);
	double GetWidth();
	void SetWidth(double);
	LPDISPATCH GetXyz();
	void SetXyz(LPDISPATCH);
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	CString Get_id();
	void Set_id(LPCTSTR);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IProbes wrapper class

class IProbes : public COleDispatchDriver
{
public:
	IProbes() {}		// Calls COleDispatchDriver default constructor
	IProbes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IProbes(const IProbes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	long GetCount();
	void SetCount(long);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	BOOL GetVisible();
	void SetVisible(BOOL);

// Operations
public:
	BOOL Add(LPCTSTR filename);
	LPDISPATCH Item(const VARIANT& NameorNum);
	void SaveChanges();
	void CancelChanges();
	LPDISPATCH _Item(const VARIANT& NameorNum);
};
/////////////////////////////////////////////////////////////////////////////
// IProbe wrapper class

class IProbe : public COleDispatchDriver
{
public:
	IProbe() {}		// Calls COleDispatchDriver default constructor
	IProbe(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IProbe(const IProbe& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	CString GetFullName();
	void SetFullName(LPCTSTR);
	CString GetName();
	void SetName(LPCTSTR);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	CString GetPath();
	void SetPath(LPCTSTR);
	LPDISPATCH GetTips();
	void SetTips(LPDISPATCH);
	long GetConnectionCount();
	void SetConnectionCount(long);
	long GetComponentCount();
	void SetComponentCount(long);
	long GetActiveComponent();
	void SetActiveComponent(long);
	long GetActiveConnection();
	void SetActiveConnection(long);
	LPDISPATCH GetQualificationSettings();
	void SetQualificationSettings(LPDISPATCH);
	BOOL GetUseWristMap();
	void SetUseWristMap(BOOL);

// Operations
public:
	void Qualify();
	BOOL Dialog();
	CString ConnectionDescription(long Item);
	CString ComponentDescription(long Item);
	void SelectAllTips();
	void ClearAllTips();
	BOOL Qualify2(LPDISPATCH Settings);
	void ResetMeasToTheoForTips();
};
/////////////////////////////////////////////////////////////////////////////
// ITips wrapper class

class ITips : public COleDispatchDriver
{
public:
	ITips() {}		// Calls COleDispatchDriver default constructor
	ITips(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ITips(const ITips& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetCount();
	void SetCount(long);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);

// Operations
public:
	LPDISPATCH Item(const VARIANT& NameorNum);
	void Remove(long Num);
	long Add(double a, double b);
	LPDISPATCH _Item(const VARIANT& NameorNum);
};
/////////////////////////////////////////////////////////////////////////////
// ITip wrapper class

class ITip : public COleDispatchDriver
{
public:
	ITip() {}		// Calls COleDispatchDriver default constructor
	ITip(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ITip(const ITip& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	double GetA();
	void SetA(double);
	double GetB();
	void SetB(double);
	double GetDiam();
	void SetDiam(double);
	CString GetDate();
	void SetDate(LPCTSTR);
	CString GetId();
	void SetId(LPCTSTR);
	LPDISPATCH GetIjk();
	void SetIjk(LPDISPATCH);
	LPDISPATCH GetMeasXYZ();
	void SetMeasXYZ(LPDISPATCH);
	double GetMeasDiam();
	void SetMeasDiam(double);
	double GetStandardDeviation();
	void SetStandardDeviation(double);
	double GetPrbRdv();
	void SetPrbRdv(double);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	CString GetTime();
	void SetTime(LPCTSTR);
	long GetTipNum();
	void SetTipNum(long);
	long GetTipType();
	void SetTipType(long);
	double GetThickness();
	void SetThickness(double);
	double GetMeasThickness();
	void SetMeasThickness(double);
	LPDISPATCH GetWristOffset();
	void SetWristOffset(LPDISPATCH);
	LPDISPATCH GetWristTipIJK();
	void SetWristTipIJK(LPDISPATCH);
	LPDISPATCH GetXyz();
	void SetXyz(LPDISPATCH);
	BOOL GetSelected();
	void SetSelected(BOOL);
	double GetC();
	void SetC(double);
	CString GetNickname();
	void SetNickname(LPCTSTR);
	CString GetDMISLabel();
	void SetDMISLabel(LPCTSTR);

// Operations
public:
	void ResetMeasToTheo();
};
/////////////////////////////////////////////////////////////////////////////
// IQualificationSettings wrapper class

class IQualificationSettings : public COleDispatchDriver
{
public:
	IQualificationSettings() {}		// Calls COleDispatchDriver default constructor
	IQualificationSettings(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IQualificationSettings(const IQualificationSettings& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetMode();
	void SetMode(long);
	double GetMoveSpeed();
	void SetMoveSpeed(double);
	long GetNumHits();
	void SetNumHits(long);
	double GetPreHit();
	void SetPreHit(double);
	double GetTouchspeed();
	void SetTouchspeed(double);
	BOOL GetShankCheck();
	void SetShankCheck(BOOL);
	double GetShankOffset();
	void SetShankOffset(double);
	long GetShankHits();
	void SetShankHits(long);
	BOOL GetUserDefinedCalibrationMode();
	void SetUserDefinedCalibrationMode(BOOL);
	double GetEndAngle();
	void SetEndAngle(double);
	double GetStartAngle();
	void SetStartAngle(double);
	long GetNumLevels();
	void SetNumLevels(long);
	BOOL GetUserDefinedCalibrationOrder();
	void SetUserDefinedCalibrationOrder(BOOL);
	double GetToolOverideI();
	void SetToolOverideI(double);
	double GetToolOverideJ();
	void SetToolOverideJ(double);
	double GetToolOverideK();
	void SetToolOverideK(double);
	BOOL GetToolOnRotaryTable();
	void SetToolOnRotaryTable(BOOL);
	BOOL GetPHSAPriority();
	void SetPHSAPriority(BOOL);
	double GetPHSTol();
	void SetPHSTol(double);
	long GetExecuteMode();
	void SetExecuteMode(long);
	long GetToolMoved();
	void SetToolMoved(long);
	long GetCreateReplaceMap();
	void SetCreateReplaceMap(long);
	double GetStartA();
	void SetStartA(double);
	double GetEndA();
	void SetEndA(double);
	double GetIncrementA();
	void SetIncrementA(double);
	double GetStartB();
	void SetStartB(double);
	double GetEndB();
	void SetEndB(double);
	double GetIncrementB();
	void SetIncrementB(double);
	double GetStartC();
	void SetStartC(double);
	double GetEndC();
	void SetEndC(double);
	double GetIncrementC();
	void SetIncrementC(double);

// Operations
public:
	LPDISPATCH GetTool();
	BOOL SetTool(LPDISPATCH tool);
};
/////////////////////////////////////////////////////////////////////////////
// IMachine wrapper class

class IMachine : public COleDispatchDriver
{
public:
	IMachine() {}		// Calls COleDispatchDriver default constructor
	IMachine(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IMachine(const IMachine& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	CString GetName();
	void SetName(LPCTSTR);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	BOOL GetIsFPanel();
	void SetIsFPanel(BOOL);
	LPDISPATCH GetFPanel();
	void SetFPanel(LPDISPATCH);
	LPDISPATCH GetProbePosition();
	void SetProbePosition(LPDISPATCH);
	long GetManAutoSelector();
	void SetManAutoSelector(long);
	CString Get_Name();
	void Set_Name(LPCTSTR);

// Operations
public:
	LPDISPATCH GetArray();
	BOOL ExecuteCustomCommand(long CommandNumber, LPDISPATCH InputIntArray, LPDISPATCH InputDoubleArray, LPDISPATCH OutputIntArray, LPDISPATCH OutputDoubleArray);
	void InsertMovePoint();
	void DeletePoint();
	void PressDone();
};
/////////////////////////////////////////////////////////////////////////////
// IMachines wrapper class

class IMachines : public COleDispatchDriver
{
public:
	IMachines() {}		// Calls COleDispatchDriver default constructor
	IMachines(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IMachines(const IMachines& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	short GetCount();
	void SetCount(short);

// Operations
public:
	LPDISPATCH Item(const VARIANT& NameorNum);
	LPDISPATCH _Item(const VARIANT& NameorNum);
};
/////////////////////////////////////////////////////////////////////////////
// IFPanel wrapper class

class IFPanel : public COleDispatchDriver
{
public:
	IFPanel() {}		// Calls COleDispatchDriver default constructor
	IFPanel(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IFPanel(const IFPanel& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetPanelSelector();
	void SetPanelSelector(long);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IArray wrapper class

class IArray : public COleDispatchDriver
{
public:
	IArray() {}		// Calls COleDispatchDriver default constructor
	IArray(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IArray(const IArray& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void SetSize(long NewSize);
	void SetValue(long ArrayPosition, double NewValue);
	double GetValue(long ArrayPosition);
	long GetSize();
};
/////////////////////////////////////////////////////////////////////////////
// IMasterSlaveDialog wrapper class

class IMasterSlaveDialog : public COleDispatchDriver
{
public:
	IMasterSlaveDialog() {}		// Calls COleDispatchDriver default constructor
	IMasterSlaveDialog(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IMasterSlaveDialog(const IMasterSlaveDialog& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetMeasuringArm();
	void SetMeasuringArm(long);
	long GetDcc();
	void SetDcc(long);
	LPDISPATCH GetPosition();
	void SetPosition(LPDISPATCH);
	CString GetMasterProbe();
	void SetMasterProbe(LPCTSTR);
	CString GetMasterTip();
	void SetMasterTip(LPCTSTR);
	CString GetSlaveProbe();
	void SetSlaveProbe(LPCTSTR);
	CString GetSlaveTip();
	void SetSlaveTip(LPCTSTR);
	CString GetTool();
	void SetTool(LPCTSTR);
	BOOL GetVisible();
	void SetVisible(BOOL);

// Operations
public:
	long Calibrate();
};
/////////////////////////////////////////////////////////////////////////////
// ICadModel wrapper class

class ICadModel : public COleDispatchDriver
{
public:
	ICadModel() {}		// Calls COleDispatchDriver default constructor
	ICadModel(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ICadModel(const ICadModel& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);

// Operations
public:
	BOOL HighlightElement(LPCTSTR Name, BOOL All);
	BOOL UnHighlightElement(LPCTSTR Name, BOOL All);
	LPDISPATCH CADSlice(double PlaneAnchorX, double PlaneAnchorY, double PlaneAnchorZ, double PlaneVectorI, double PlaneVectorJ, double PlaneVectorK, double Tolerance);
	LPDISPATCH CadCollectionSlice(long CADType, double PlaneAnchorX, double PlaneAnchorY, double PlaneAnchorZ, double PlaneVectorI, double PlaneVectorJ, double PlaneVectorK, double Tolerance);
	BOOL ScaleToFit(LPDISPATCH Command);
	long CADProjectPoint(double pointX, double pointY, double pointZ, long geometryFilterFlags, long vectorOption, long surfaceBoundaryOption, double* pProjectPointX, double* pProjectPointY, double* pProjectPointZ, double* pProjectVectorI, 
		double* pProjectVectorJ, double* pProjectVectorK, LPDISPATCH pCadHandle);
	LPDISPATCH GetEmptyCadHandle();
	long CADIntersectLine(double linePointX, double linePointY, double linePointZ, double lineVectorI, double lineVectorJ, double lineVectorK, long geometryFilterFlags, long vectorOption, long surfaceBoundaryOption, long lineIntersectFlags, 
		double* pIntersectPointX, double* pIntersectPointY, double* pIntersectPointZ, double* pIntersectVectorI, double* pIntersectVectorJ, double* pIntersectVectorK, LPDISPATCH pCadHandle);
	long CADIntersectPlane(double planePointX, double planePointY, double planePointZ, double PlaneVectorI, double PlaneVectorJ, double PlaneVectorK, long geometryFilterFlags, long vectorOption, long surfaceBoundaryOption, 
		double* pIntersectPointX, double* pIntersectPointY, double* pIntersectPointZ, double* pIntersectVectorI, double* pIntersectVectorJ, double* pIntersectVectorK, LPDISPATCH pCadHandle);
};
/////////////////////////////////////////////////////////////////////////////
// ICadPolyLinesOnSurface wrapper class

class ICadPolyLinesOnSurface : public COleDispatchDriver
{
public:
	ICadPolyLinesOnSurface() {}		// Calls COleDispatchDriver default constructor
	ICadPolyLinesOnSurface(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ICadPolyLinesOnSurface(const ICadPolyLinesOnSurface& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	long GetCount();
	void SetCount(long);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);

// Operations
public:
	LPDISPATCH Item(long Num);
	LPDISPATCH _Item(long Num);
};
/////////////////////////////////////////////////////////////////////////////
// ICadPolyLineOnSurface wrapper class

class ICadPolyLineOnSurface : public COleDispatchDriver
{
public:
	ICadPolyLineOnSurface() {}		// Calls COleDispatchDriver default constructor
	ICadPolyLineOnSurface(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ICadPolyLineOnSurface(const ICadPolyLineOnSurface& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetCadPoints();
	void SetCadPoints(LPDISPATCH);
	BOOL GetClosed();
	void SetClosed(BOOL);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// ICadPointsOnSurface wrapper class

class ICadPointsOnSurface : public COleDispatchDriver
{
public:
	ICadPointsOnSurface() {}		// Calls COleDispatchDriver default constructor
	ICadPointsOnSurface(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ICadPointsOnSurface(const ICadPointsOnSurface& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	long GetCount();
	void SetCount(long);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);

// Operations
public:
	LPDISPATCH Item(long Num);
	LPDISPATCH _Item(long Num);
};
/////////////////////////////////////////////////////////////////////////////
// ICadPointOnSurface wrapper class

class ICadPointOnSurface : public COleDispatchDriver
{
public:
	ICadPointOnSurface() {}		// Calls COleDispatchDriver default constructor
	ICadPointOnSurface(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ICadPointOnSurface(const ICadPointOnSurface& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	double GetX();
	void SetX(double);
	double GetY();
	void SetY(double);
	double GetZ();
	void SetZ(double);
	double GetI();
	void SetI(double);
	double GetJ();
	void SetJ(double);
	double GetK();
	void SetK(double);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// ICadHandle wrapper class

class ICadHandle : public COleDispatchDriver
{
public:
	ICadHandle() {}		// Calls COleDispatchDriver default constructor
	ICadHandle(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ICadHandle(const ICadHandle& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetCollection();
	void SetCollection(long);
	long GetPartInstanceId();
	void SetPartInstanceId(long);
	long GetSubCadId();
	void SetSubCadId(long);
	long GetCadSequence();
	void SetCadSequence(long);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IPartProgramSettings wrapper class

class IPartProgramSettings : public COleDispatchDriver
{
public:
	IPartProgramSettings() {}		// Calls COleDispatchDriver default constructor
	IPartProgramSettings(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IPartProgramSettings(const IPartProgramSettings& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetAutoAdjustPh9();
	void SetAutoAdjustPh9(long);
	long GetWarnLoadProbe();
	void SetWarnLoadProbe(long);
	long GetAutoLabelPosition();
	void SetAutoLabelPosition(long);
	long GetPointOnlyMode();
	void SetPointOnlyMode(long);
	long GetResetGlobalsWhenBranching();
	void SetResetGlobalsWhenBranching(long);
	long GetMinusTolerancesShowNegative();
	void SetMinusTolerancesShowNegative(long);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IExecutedCommands wrapper class

class IExecutedCommands : public COleDispatchDriver
{
public:
	IExecutedCommands() {}		// Calls COleDispatchDriver default constructor
	IExecutedCommands(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IExecutedCommands(const IExecutedCommands& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetCount();
	void SetCount(long);

// Operations
public:
	LPDISPATCH Item(long Num);
	LPDISPATCH FindByUniqueID(long HiPart, long LoPart);
	LPDISPATCH _Item(const VARIANT& Identifier);
};
/////////////////////////////////////////////////////////////////////////////
// IReportWindow wrapper class

class IReportWindow : public COleDispatchDriver
{
public:
	IReportWindow() {}		// Calls COleDispatchDriver default constructor
	IReportWindow(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IReportWindow(const IReportWindow& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetVisible();
	void SetVisible(long);
	LPDISPATCH GetPages();
	void SetPages(LPDISPATCH);
	CString GetCurrentReport();
	void SetCurrentReport(LPCTSTR);
	long GetCustomReportCount();
	void SetCustomReportCount(long);
	long GetLeft();
	void SetLeft(long);
	long GetWidth();
	void SetWidth(long);
	long GetTop();
	void SetTop(long);
	long GetHeight();
	void SetHeight(long);

// Operations
public:
	long LoadReportTemplate(LPCTSTR filename);
	long SetCurrentAsDefaultReport();
	long PrintReport();
	long RefreshReport();
	long FullReportMode();
	long LastExecutionReportMode();
	CString GetCustomReportName(long index);
	long LoadCustomReport(const VARIANT& NameOrNumber);
	long GenerateStatusReportBitmapUid(LPCTSTR filename, LPCTSTR templatename, long* HiPart, long* LoPart);
	long GenerateStatusReportBitmapId(LPCTSTR filename, LPCTSTR templatename, LPCTSTR start, LPCTSTR end);
	long GenerateStatusReportBitmap(LPCTSTR filename, LPCTSTR templatename, LPDISPATCH startCmd, LPDISPATCH endCmd);
};
/////////////////////////////////////////////////////////////////////////////
// IPages wrapper class

class IPages : public COleDispatchDriver
{
public:
	IPages() {}		// Calls COleDispatchDriver default constructor
	IPages(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IPages(const IPages& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetCount();
	void SetCount(long);

// Operations
public:
	LPDISPATCH Item(long Num);
	LPDISPATCH _Item(long Num);
};
/////////////////////////////////////////////////////////////////////////////
// IPage wrapper class

class IPage : public COleDispatchDriver
{
public:
	IPage() {}		// Calls COleDispatchDriver default constructor
	IPage(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IPage(const IPage& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetNumber();
	void SetNumber(long);
	LPDISPATCH GetReportControls();
	void SetReportControls(LPDISPATCH);
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetHeight();
	void SetHeight(long);
	long GetWidth();
	void SetWidth(long);
	long GetLandScape();
	void SetLandScape(long);
	long GetSection();
	void SetSection(long);
	long GetDuplicated();
	void SetDuplicated(long);
	long GetCustom();
	void SetCustom(long);
	long GetPageNumber();
	void SetPageNumber(long);
	long GetLeft();
	void SetLeft(long);
	long GetRight();
	void SetRight(long);
	long GetTop();
	void SetTop(long);
	long GetBottom();
	void SetBottom(long);
	long Get_Number();
	void Set_Number(long);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IReportControls wrapper class

class IReportControls : public COleDispatchDriver
{
public:
	IReportControls() {}		// Calls COleDispatchDriver default constructor
	IReportControls(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IReportControls(const IReportControls& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetCount();
	void SetCount(long);
	long GetReadOnly();
	void SetReadOnly(long);

// Operations
public:
	LPDISPATCH Item(const VARIANT& NameOrNumber);
	LPDISPATCH Add(long ObjectType, long Left, long Top, long Right, long Bottom);
	long Remove(const VARIANT& NameOrNumber);
	LPDISPATCH ItemControl(const VARIANT& NameOrNumber);
	LPDISPATCH AddControl(long ObjectType, long Left, long Top, long Right, long Bottom);
	void RefreshControls();
	LPDISPATCH _Item(const VARIANT& NameOrNumber);
};
/////////////////////////////////////////////////////////////////////////////
// IReportControl wrapper class

class IReportControl : public COleDispatchDriver
{
public:
	IReportControl() {}		// Calls COleDispatchDriver default constructor
	IReportControl(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IReportControl(const IReportControl& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetTop();
	void SetTop(long);
	long GetBottom();
	void SetBottom(long);
	long GetLeft();
	void SetLeft(long);
	long GetRight();
	void SetRight(long);
	CString GetId();
	void SetId(LPCTSTR);
	long GetSelected();
	void SetSelected(long);
	long GetVisible();
	void SetVisible(long);
	long GetHeight();
	void SetHeight(long);
	long GetWidth();
	void SetWidth(long);
	long GetType();
	void SetType(long);
	LPDISPATCH GetCommand();
	void SetCommand(LPDISPATCH);
	CString GetLabelTemplateName();
	void SetLabelTemplateName(LPCTSTR);
	CString GetCADReferenceName();
	void SetCADReferenceName(LPCTSTR);
	long GetLeaderLineVisible();
	void SetLeaderLineVisible(long);
	long GetIsAnalysisWindow();
	void SetIsAnalysisWindow(long);
	long GetIsLabel();
	void SetIsLabel(long);
	long GetIsLeaderLine();
	void SetIsLeaderLine(long);
	LPDISPATCH GetAnalysisWindow();
	void SetAnalysisWindow(LPDISPATCH);
	LPDISPATCH GetOffset();
	void SetOffset(LPDISPATCH);
	double GetScaleFactor();
	void SetScaleFactor(double);
	LPDISPATCH GetRotation();
	void SetRotation(LPDISPATCH);

// Operations
public:
	long FlipCROView(long _isVertical);
	long FlipCROViewByAxis(long _axisToUse);
};
/////////////////////////////////////////////////////////////////////////////
// IQuickStart wrapper class

class IQuickStart : public COleDispatchDriver
{
public:
	IQuickStart() {}		// Calls COleDispatchDriver default constructor
	IQuickStart(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IQuickStart(const IQuickStart& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetCurrentTask();
	void SetCurrentTask(LPDISPATCH);

// Operations
public:
	LPDISPATCH BeginTask(long TaskNum);
	BOOL RemoveHit();
};
/////////////////////////////////////////////////////////////////////////////
// IQuickStartTask wrapper class

class IQuickStartTask : public COleDispatchDriver
{
public:
	IQuickStartTask() {}		// Calls COleDispatchDriver default constructor
	IQuickStartTask(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IQuickStartTask(const IQuickStartTask& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetSteps();
	void SetSteps(LPDISPATCH);
	long GetNumSteps();
	void SetNumSteps(long);

// Operations
public:
	LPDISPATCH NextStep();
	LPDISPATCH PrevStep();
	LPDISPATCH Finish();
};
/////////////////////////////////////////////////////////////////////////////
// IQuickStartSteps wrapper class

class IQuickStartSteps : public COleDispatchDriver
{
public:
	IQuickStartSteps() {}		// Calls COleDispatchDriver default constructor
	IQuickStartSteps(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IQuickStartSteps(const IQuickStartSteps& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetCount();
	void SetCount(long);

// Operations
public:
	LPDISPATCH Item(long Num);
	LPDISPATCH _Item(long Num);
};
/////////////////////////////////////////////////////////////////////////////
// IQuickStartStep wrapper class

class IQuickStartStep : public COleDispatchDriver
{
public:
	IQuickStartStep() {}		// Calls COleDispatchDriver default constructor
	IQuickStartStep(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IQuickStartStep(const IQuickStartStep& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	BOOL GetExpectsHits();
	void SetExpectsHits(BOOL);
	BOOL GetExpectsUserInput();
	void SetExpectsUserInput(BOOL);
	long GetNumHits();
	void SetNumHits(long);
	CString GetStepHint();
	void SetStepHint(LPCTSTR);
	BOOL GetCanBeCompleted();
	void SetCanBeCompleted(BOOL);

// Operations
public:
	CString GetPrompt(long Num);
	CString GetEditText(long Num);
	void SetEditText(long Num, LPCTSTR Value);
	CString GetControlText(long Num);
	BOOL GetControlState(long Num);
	void SetControlState(long Num, BOOL Value);
	CString GetSelectionPrompt();
};
/////////////////////////////////////////////////////////////////////////////
// IQuickStartAddedCommands wrapper class

class IQuickStartAddedCommands : public COleDispatchDriver
{
public:
	IQuickStartAddedCommands() {}		// Calls COleDispatchDriver default constructor
	IQuickStartAddedCommands(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IQuickStartAddedCommands(const IQuickStartAddedCommands& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetCount();
	void SetCount(long);

// Operations
public:
	LPDISPATCH Item(long Num);
	LPDISPATCH _Item(long Num);
};
/////////////////////////////////////////////////////////////////////////////
// IBundledStations wrapper class

class IBundledStations : public COleDispatchDriver
{
public:
	IBundledStations() {}		// Calls COleDispatchDriver default constructor
	IBundledStations(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IBundledStations(const IBundledStations& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetCount();
	void SetCount(long);
	LPDISPATCH GetActiveStation();
	void SetActiveStation(LPDISPATCH);
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);

// Operations
public:
	LPDISPATCH Add();
	BOOL Remove(const VARIANT& StringOrNumber);
	LPDISPATCH Item(const VARIANT& StringOrNumber);
	LPDISPATCH _Item(const VARIANT& StringOrNumber);
};
/////////////////////////////////////////////////////////////////////////////
// IBundledStation wrapper class

class IBundledStation : public COleDispatchDriver
{
public:
	IBundledStation() {}		// Calls COleDispatchDriver default constructor
	IBundledStation(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IBundledStation(const IBundledStation& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	CString GetId();
	void SetId(LPCTSTR);
	long GetIndexID();
	void SetIndexID(long);
	BOOL GetOriented();
	void SetOriented(BOOL);
	BOOL GetLocked();
	void SetLocked(BOOL);
	BOOL GetIsActive();
	void SetIsActive(BOOL);
	LPDISPATCH GetMatrix();
	void SetMatrix(LPDISPATCH);
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	CString Get_id();
	void Set_id(LPCTSTR);

// Operations
public:
	BOOL SetActive();
};
/////////////////////////////////////////////////////////////////////////////
// ISection wrapper class

class ISection : public COleDispatchDriver
{
public:
	ISection() {}		// Calls COleDispatchDriver default constructor
	ISection(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISection(const ISection& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	CString GetName();
	void SetName(LPCTSTR);
	long GetNumber();
	void SetNumber(long);
	LPDISPATCH GetReportControls();
	void SetReportControls(LPDISPATCH);
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetHeight();
	void SetHeight(long);
	long GetWidth();
	void SetWidth(long);
	CString Get_Name();
	void Set_Name(LPCTSTR);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// ISections wrapper class

class ISections : public COleDispatchDriver
{
public:
	ISections() {}		// Calls COleDispatchDriver default constructor
	ISections(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ISections(const ISections& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetCount();
	void SetCount(long);
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);

// Operations
public:
	LPDISPATCH Add(LPCTSTR Name);
	BOOL Remove(const VARIANT& NameOrNumber);
	LPDISPATCH Item(const VARIANT& NameOrNumber);
	LPDISPATCH InsertSectionBefore(LPCTSTR Name);
	LPDISPATCH _Item(const VARIANT& NameOrNumber);
};
/////////////////////////////////////////////////////////////////////////////
// IReportTemplate wrapper class

class IReportTemplate : public COleDispatchDriver
{
public:
	IReportTemplate() {}		// Calls COleDispatchDriver default constructor
	IReportTemplate(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IReportTemplate(const IReportTemplate& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	BOOL GetVisible();
	void SetVisible(BOOL);
	LPDISPATCH GetSections();
	void SetSections(LPDISPATCH);
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	CString GetName();
	void SetName(LPCTSTR);
	CString GetFullName();
	void SetFullName(LPCTSTR);
	LPDISPATCH GetColors();
	void SetColors(LPDISPATCH);
	CString GetLearnTimeProgram();
	void SetLearnTimeProgram(LPCTSTR);
	CString GetRunTimeProgram();
	void SetRunTimeProgram(LPCTSTR);
	long GetPageOrientation();
	void SetPageOrientation(long);
	long GetPageSize();
	void SetPageSize(long);
	CString Get_Name();
	void Set_Name(LPCTSTR);

// Operations
public:
	BOOL Save();
	BOOL SaveAs(LPCTSTR filename);
	void Close();
};
/////////////////////////////////////////////////////////////////////////////
// IReportTemplates wrapper class

class IReportTemplates : public COleDispatchDriver
{
public:
	IReportTemplates() {}		// Calls COleDispatchDriver default constructor
	IReportTemplates(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IReportTemplates(const IReportTemplates& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetCount();
	void SetCount(long);

// Operations
public:
	LPDISPATCH Open(LPCTSTR filename);
	LPDISPATCH Add();
	LPDISPATCH Item(const VARIANT& NameOrNumber);
	LPDISPATCH _Item(const VARIANT& NameOrNumber);
};
/////////////////////////////////////////////////////////////////////////////
// IColors wrapper class

class IColors : public COleDispatchDriver
{
public:
	IColors() {}		// Calls COleDispatchDriver default constructor
	IColors(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IColors(const IColors& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetModified();
	void SetModified(long);
	long GetBackground();
	void SetBackground(long);
	long GetDimensionBackground();
	void SetDimensionBackground(long);
	long GetHighLightBackground();
	void SetHighLightBackground(long);
	long GetNumTableColors();
	void SetNumTableColors(long);
	long GetCount();
	void SetCount(long);

// Operations
public:
	// method 'Add' not emitted because of invalid return type or parameter type
	// method 'Item' not emitted because of invalid return type or parameter type
	// method 'IsAllowed' not emitted because of invalid return type or parameter type
	// method 'UsedColor' not emitted because of invalid return type or parameter type
	void SaveChanges();
	void DiscardChanges();
	void BuildColortable();
	long GetColorTableColor(long colorIndex);
};
/////////////////////////////////////////////////////////////////////////////
// IColor wrapper class

class IColor : public COleDispatchDriver
{
public:
	IColor() {}		// Calls COleDispatchDriver default constructor
	IColor(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IColor(const IColor& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long Get_Standard();
	void Set_Standard(long);
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetColorParentType();
	void SetColorParentType(long);
	long GetStandard();
	void SetStandard(long);
	long GetMarked();
	void SetMarked(long);
	long GetDebug();
	void SetDebug(long);
	long GetOutTol();
	void SetOutTol(long);
	long GetStandardBackground();
	void SetStandardBackground(long);
	long GetMarkedBackground();
	void SetMarkedBackground(long);

// Operations
public:
	void Remove();
	void SaveChanges();
	void DiscardChanges();
	// method 'GetType' not emitted because of invalid return type or parameter type
};
/////////////////////////////////////////////////////////////////////////////
// IExecutionWindow wrapper class

class IExecutionWindow : public COleDispatchDriver
{
public:
	IExecutionWindow() {}		// Calls COleDispatchDriver default constructor
	IExecutionWindow(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IExecutionWindow(const IExecutionWindow& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	BOOL GetVisible();
	void SetVisible(BOOL);
	BOOL GetAvailable();
	void SetAvailable(BOOL);
	long GetLeft();
	void SetLeft(long);
	long GetWidth();
	void SetWidth(long);
	long GetTop();
	void SetTop(long);
	long GetHeight();
	void SetHeight(long);
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	long GetArmNumber();
	void SetArmNumber(long);
	BOOL Get_Visible();
	void Set_Visible(BOOL);
	BOOL GetShowStopButton();
	void SetShowStopButton(BOOL);
	BOOL GetShowSkipButton();
	void SetShowSkipButton(BOOL);
	BOOL GetShowContinueButton();
	void SetShowContinueButton(BOOL);
	BOOL GetShowJumpButton();
	void SetShowJumpButton(BOOL);

// Operations
public:
	void CancelExecution();
	void EraseHit();
	void Continue();
	void stop();
	void Skip();
	void Jump();
	void StepNext();
	void StepInto();
	void NewRow();
	void ScanDone();
	void Watch();
	void ScaleProbe();
};
/////////////////////////////////////////////////////////////////////////////
// IReadoutWindow wrapper class

class IReadoutWindow : public COleDispatchDriver
{
public:
	IReadoutWindow() {}		// Calls COleDispatchDriver default constructor
	IReadoutWindow(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IReadoutWindow(const IReadoutWindow& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	BOOL GetVisible();
	void SetVisible(BOOL);
	long GetLeft();
	void SetLeft(long);
	long GetWidth();
	void SetWidth(long);
	long GetTop();
	void SetTop(long);
	long GetHeight();
	void SetHeight(long);
	BOOL GetMinimized();
	void SetMinimized(BOOL);
	BOOL GetMaximized();
	void SetMaximized(BOOL);
	BOOL GetShowFeatureID();
	void SetShowFeatureID(BOOL);
	BOOL GetShowFeatureType();
	void SetShowFeatureType(BOOL);
	BOOL GetShowProbePosition();
	void SetShowProbePosition(BOOL);
	BOOL GetShowLastHit();
	void SetShowLastHit(BOOL);
	BOOL GetShowErrorLastMeasuredFeature();
	void SetShowErrorLastMeasuredFeature(BOOL);
	BOOL GetShowCurrentProbePositionOnScreen();
	void SetShowCurrentProbePositionOnScreen(BOOL);
	BOOL GetShowDeviationArrowOnScreen();
	void SetShowDeviationArrowOnScreen(BOOL);
	BOOL GetCenterProbeOnGraphicsWindow();
	void SetCenterProbeOnGraphicsWindow(BOOL);
	BOOL GetDisplayXAxis();
	void SetDisplayXAxis(BOOL);
	BOOL GetDisplayYAxis();
	void SetDisplayYAxis(BOOL);
	BOOL GetDisplayZAxis();
	void SetDisplayZAxis(BOOL);
	BOOL GetUseMachineCoordinateSystem();
	void SetUseMachineCoordinateSystem(BOOL);
	BOOL GetUsePolarCoordinates();
	void SetUsePolarCoordinates(BOOL);
	BOOL GetShowDistanceToTarget();
	void SetShowDistanceToTarget(BOOL);
	BOOL GetShowDistanceToTargetWithAutoZoom();
	void SetShowDistanceToTargetWithAutoZoom(BOOL);
	BOOL GetShowDistanceToTargetToExecutingFeature();
	void SetShowDistanceToTargetToExecutingFeature(BOOL);
	BOOL GetShowDistanceToTargetToClosestFeature();
	void SetShowDistanceToTargetToClosestFeature(BOOL);
	BOOL GetShowTargetToSurfaceEdge();
	void SetShowTargetToSurfaceEdge(BOOL);
	BOOL GetShowTargetToCentroid();
	void SetShowTargetToCentroid(BOOL);
	BOOL GetDisplayDistanceToClosestCAD();
	void SetDisplayDistanceToClosestCAD(BOOL);
	BOOL GetApplyDimensionColor();
	void SetApplyDimensionColor(BOOL);
	long GetDisplayPromptHistory();
	void SetDisplayPromptHistory(long);
	BOOL GetTrackerShowRMS();
	void SetTrackerShowRMS(BOOL);
	BOOL GetTrackerBuildMode();
	void SetTrackerBuildMode(BOOL);
	BOOL GetTrackerInspectMode();
	void SetTrackerInspectMode(BOOL);
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	BOOL GetAvailable();
	void SetAvailable(BOOL);
	long GetHitCount();
	void SetHitCount(long);
	BOOL Get_Visible();
	void Set_Visible(BOOL);

// Operations
public:
	double GetAAngle(long ArmNumber);
	double GetBAngle(long ArmNumber);
};
/////////////////////////////////////////////////////////////////////////////
// IApplicationObjectEvents wrapper class

class IApplicationObjectEvents : public COleDispatchDriver
{
public:
	IApplicationObjectEvents() {}		// Calls COleDispatchDriver default constructor
	IApplicationObjectEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IApplicationObjectEvents(const IApplicationObjectEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IApplicationSettings wrapper class

class IApplicationSettings : public COleDispatchDriver
{
public:
	IApplicationSettings() {}		// Calls COleDispatchDriver default constructor
	IApplicationSettings(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IApplicationSettings(const IApplicationSettings& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetWarnOkMovPh9();
	void SetWarnOkMovPh9(long);
	long GetWarnOkRotPh9();
	void SetWarnOkRotPh9(long);
	long GetWarningDefaultOkRotPh9();
	void SetWarningDefaultOkRotPh9(long);
	long GetWarnNoSavePrg();
	void SetWarnNoSavePrg(long);
	long GetWarnOverwritingAlignment();
	void SetWarnOverwritingAlignment(long);
	long GetWarningDefaultNoSavePrg();
	void SetWarningDefaultNoSavePrg(long);
	long GetWarningDefaultOverwritingAlignment();
	void SetWarningDefaultOverwritingAlignment(long);
	long GetWarnOKUsePh9();
	void SetWarnOKUsePh9(long);

// Operations
public:
	// method 'SetWarning' not emitted because of invalid return type or parameter type
};
/////////////////////////////////////////////////////////////////////////////
// ILabelTemplates wrapper class

class ILabelTemplates : public COleDispatchDriver
{
public:
	ILabelTemplates() {}		// Calls COleDispatchDriver default constructor
	ILabelTemplates(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ILabelTemplates(const ILabelTemplates& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetCount();
	void SetCount(long);

// Operations
public:
	LPDISPATCH Open(LPCTSTR filename);
	LPDISPATCH Add();
	LPDISPATCH Item(const VARIANT& NameOrNumber);
	LPDISPATCH _Item(const VARIANT& NameOrNumber);
};
/////////////////////////////////////////////////////////////////////////////
// ILabelTemplate wrapper class

class ILabelTemplate : public COleDispatchDriver
{
public:
	ILabelTemplate() {}		// Calls COleDispatchDriver default constructor
	ILabelTemplate(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ILabelTemplate(const ILabelTemplate& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	BOOL GetVisible();
	void SetVisible(BOOL);
	LPDISPATCH GetLabelControls();
	void SetLabelControls(LPDISPATCH);
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	CString GetName();
	void SetName(LPCTSTR);
	CString GetFullName();
	void SetFullName(LPCTSTR);
	CString Get_Name();
	void Set_Name(LPCTSTR);

// Operations
public:
	BOOL Save();
	BOOL SaveAs(LPCTSTR filename);
	void Close();
};
/////////////////////////////////////////////////////////////////////////////
// ILabelControls wrapper class

class ILabelControls : public COleDispatchDriver
{
public:
	ILabelControls() {}		// Calls COleDispatchDriver default constructor
	ILabelControls(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ILabelControls(const ILabelControls& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetCount();
	void SetCount(long);

// Operations
public:
	LPDISPATCH Item(const VARIANT& NameOrNumber);
	LPDISPATCH Add(long ObjectType, long Left, long Top, long Right, long Bottom);
	long Remove(const VARIANT& NameOrNumber);
	LPDISPATCH _Item(const VARIANT& NameOrNumber);
};
/////////////////////////////////////////////////////////////////////////////
// IPortLock wrapper class

class IPortLock : public COleDispatchDriver
{
public:
	IPortLock() {}		// Calls COleDispatchDriver default constructor
	IPortLock(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IPortLock(const IPortLock& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetLockID();
	void SetLockID(long);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long Get_id();
	void Set_id(long);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// INotificationSettings wrapper class

class INotificationSettings : public COleDispatchDriver
{
public:
	INotificationSettings() {}		// Calls COleDispatchDriver default constructor
	INotificationSettings(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	INotificationSettings(const INotificationSettings& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	BOOL GetNotificationON();
	void SetNotificationON(BOOL);

// Operations
public:
	void ResetDevice();
};
/////////////////////////////////////////////////////////////////////////////
// IRegistrySettings wrapper class

class IRegistrySettings : public COleDispatchDriver
{
public:
	IRegistrySettings() {}		// Calls COleDispatchDriver default constructor
	IRegistrySettings(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IRegistrySettings(const IRegistrySettings& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetCount();
	void SetCount(long);

// Operations
public:
	LPDISPATCH Item(const VARIANT& Identifier);
	LPDISPATCH First();
	LPDISPATCH Next(LPDISPATCH Identifier);
	void RemoveAll();
};
/////////////////////////////////////////////////////////////////////////////
// IRegistrySetting wrapper class

class IRegistrySetting : public COleDispatchDriver
{
public:
	IRegistrySetting() {}		// Calls COleDispatchDriver default constructor
	IRegistrySetting(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IRegistrySetting(const IRegistrySetting& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	CString GetKeyName();
	void SetKeyName(LPCTSTR);
	CString GetValueName();
	void SetValueName(LPCTSTR);
	CString GetValue();
	void SetValue(LPCTSTR);
	long GetType();
	void SetType(long);
	BOOL GetUsed();
	void SetUsed(BOOL);
	long GetAccessLevel();
	void SetAccessLevel(long);
	long GetGroup();
	void SetGroup(long);

// Operations
public:
	void DeleteKey();
	BOOL IsWriteable();
};
/////////////////////////////////////////////////////////////////////////////
// IPartProgramEvents wrapper class

class IPartProgramEvents : public COleDispatchDriver
{
public:
	IPartProgramEvents() {}		// Calls COleDispatchDriver default constructor
	IPartProgramEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IPartProgramEvents(const IPartProgramEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void OnObjectAboutToExecute(LPDISPATCH Command);
	void OnObjectExecuted(LPDISPATCH Command);
	void OnStartExecution();
	void OnEndExecution(long TerminationType);
	void OnAddObject(LPDISPATCH Command);
	void OnExecuteDialogErrorMsg(LPCTSTR ErrorMsg);
	void OnExecuteDialogStatusMsg(LPCTSTR StatusMsg);
	void OnObjectAboutToExecute2(LPDISPATCH Command, long Arm);
	void OnObjectExecuted2(LPDISPATCH Command, long Arm);
	void OnWorkOffset(double dX, double dY, double dZ, double rx, double ry, double rz, LPCTSTR file, LPCTSTR progname, LPCTSTR gcode);
	void OnToolOffset(double dd, double dl, LPCTSTR file, LPCTSTR progname, LPCTSTR toolNumber);
	void OnWriteCncVar(long index, double val);
	void OnReadCncVar(long index, double* pval);
	void OnGuess(LPDISPATCH Command, long Arm);
};
/////////////////////////////////////////////////////////////////////////////
// IMachineEvents wrapper class

class IMachineEvents : public COleDispatchDriver
{
public:
	IMachineEvents() {}		// Calls COleDispatchDriver default constructor
	IMachineEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IMachineEvents(const IMachineEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void LearnHit(double X, double Y, double Z, double I, double J, double K);
	void ExecuteHit(double X, double Y, double Z, double I, double J, double K);
	void ErrorMsg(LPCTSTR Msg, long ErrorType);
	void Command(long Code);
	void Readout(double X, double Y, double Z, double I, double J, double K);
	void ExecuteManualScanHit(double X, double Y, double Z, double I, double J, double K);
	void FeatureID(LPCTSTR fid);
	void FeatureType(LPCTSTR ftype);
	void RMS(double RMS);
	void DistanceToTarget(double dX, double dY, double dZ, double T, double tol);
	void DistanceToClosestCAD(double dX, double dY, double dZ, double T, double tol);
	void ReadoutExt(double X, double Y, double Z);
};
/////////////////////////////////////////////////////////////////////////////
// IAutotrigger wrapper class

class IAutotrigger : public COleDispatchDriver
{
public:
	IAutotrigger() {}		// Calls COleDispatchDriver default constructor
	IAutotrigger(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IAutotrigger(const IAutotrigger& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetAutotriggeron();
	void SetAutotriggeron(long);
	long GetBeepingon();
	void SetBeepingon(long);
	double GetRadius();
	void SetRadius(double);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IApplicationEvents wrapper class

class IApplicationEvents : public COleDispatchDriver
{
public:
	IApplicationEvents() {}		// Calls COleDispatchDriver default constructor
	IApplicationEvents(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IApplicationEvents(const IApplicationEvents& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	void OnObjectAboutToExecute(LPDISPATCH PartProg, LPDISPATCH Cmmd);
	void OnObjectExecuted(LPDISPATCH PartProg, LPDISPATCH Cmmd);
	void OnStartExecution(LPDISPATCH PartProg);
	void OnEndExecution(LPDISPATCH PartProg, long TerminationType);
	void OnAddObject(LPDISPATCH PartProg, LPDISPATCH Command);
	void OnOpenPartProgram(LPDISPATCH PartProg);
	void OnClosePartProgram(LPDISPATCH PartProg);
	void OnSavePartProgram(LPDISPATCH PartProg);
	void OnUpdateStatusMessage(LPCTSTR Msg);
	void OnOpenRemotePanelDialog(LPDISPATCH PartProg, long DialogId, long hWnd, LPCTSTR Message, long BtnId1, long BtnId2, long BtnId3, long BtnId4, long DefaultBtn);
	void OnConnectSlave(LPDISPATCH PartProg);
	void OnDisconnectSlave(LPDISPATCH PartProg);
	void OnObjectAboutToExecute2(LPDISPATCH PartProg, LPDISPATCH Cmmd, long Arm);
	void OnObjectExecuted2(LPDISPATCH PartProg, LPDISPATCH Cmmd, long Arm);
	void OnOpenRemotePanelDialog2(LPDISPATCH PartProg, long DialogId, long hWnd, LPCTSTR Message, long BtnId1, long BtnId2, long BtnId3, long BtnId4, long BtnId5, long DefaultBtn);
	void OnCloseRemotePanelDialog(LPDISPATCH PartProg, long DialogId, long hClosedWnd, LPCTSTR Message, long PushedBtnID);
	void OnPCDMessageBoxOpen(LPDISPATCH PCDMessageBox);
	void OnPCDMessageBoxClose(LPDISPATCH PCDMessageBox, long PushedBtnID);
	void OnOpenExecutionDialog(LPDISPATCH ExecutionWindow);
	void OnCloseExecutionDialog(LPDISPATCH ExecutionWindow);
	void OnCommentInputDialogOpen(LPDISPATCH CommentInputDialog);
	void OnCommentInputDialogClose(LPDISPATCH CommentInputDialog, long PushedBtnID);
	void OnExecutionDialogButton(LPDISPATCH ExecutionWindow, long PushedBtnID);
};
/////////////////////////////////////////////////////////////////////////////
// IPCDMessageBox wrapper class

class IPCDMessageBox : public COleDispatchDriver
{
public:
	IPCDMessageBox() {}		// Calls COleDispatchDriver default constructor
	IPCDMessageBox(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IPCDMessageBox(const IPCDMessageBox& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	BOOL GetIsClosed();
	void SetIsClosed(BOOL);
	CString GetCaption();
	void SetCaption(LPCTSTR);
	CString GetMessage();
	void SetMessage(LPCTSTR);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	BOOL GetHasShutDownButton();
	void SetHasShutDownButton(BOOL);

// Operations
public:
	BOOL HasButton(long ButtonType);
	long PressButton(long ButtonType);
	long PressShutDownButton();
};
/////////////////////////////////////////////////////////////////////////////
// ICommentInputDialog wrapper class

class ICommentInputDialog : public COleDispatchDriver
{
public:
	ICommentInputDialog() {}		// Calls COleDispatchDriver default constructor
	ICommentInputDialog(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	ICommentInputDialog(const ICommentInputDialog& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	BOOL GetIsClosed();
	void SetIsClosed(BOOL);
	CString GetCaption();
	void SetCaption(LPCTSTR);
	CString GetMessage();
	void SetMessage(LPCTSTR);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);

// Operations
public:
	long PressOKButton();
	long PressCancelButton();
	long SetInputText(LPCTSTR InputText);
};
/////////////////////////////////////////////////////////////////////////////
// Itutorhit wrapper class

class Itutorhit : public COleDispatchDriver
{
public:
	Itutorhit() {}		// Calls COleDispatchDriver default constructor
	Itutorhit(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	Itutorhit(const Itutorhit& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// IAnalysisWindow wrapper class

class IAnalysisWindow : public COleDispatchDriver
{
public:
	IAnalysisWindow() {}		// Calls COleDispatchDriver default constructor
	IAnalysisWindow(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IAnalysisWindow(const IAnalysisWindow& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetTransparent();
	void SetTransparent(long);
	double GetMaxMinSize();
	void SetMaxMinSize(double);
	long GetMaxColor();
	void SetMaxColor(long);
	long GetMinColor();
	void SetMinColor(long);
	long GetTrihedron();
	void SetTrihedron(long);
	long GetTitle();
	void SetTitle(long);
	long GetDeviations();
	void SetDeviations(long);
	long GetBorder();
	void SetBorder(long);
	long GetLabelOffset();
	void SetLabelOffset(long);
	LPDISPATCH GetHOBPointInfoList();
	void SetHOBPointInfoList(LPDISPATCH);

// Operations
public:
	void RepaintCustomReport(long i_bNeedUpdate);
};
/////////////////////////////////////////////////////////////////////////////
// IHOBPointInfoList wrapper class

class IHOBPointInfoList : public COleDispatchDriver
{
public:
	IHOBPointInfoList() {}		// Calls COleDispatchDriver default constructor
	IHOBPointInfoList(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IHOBPointInfoList(const IHOBPointInfoList& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetCount();
	void SetCount(long);

// Operations
public:
	LPDISPATCH Item(long i_nIndex);
	CString ID(long i_nIndex);
};
/////////////////////////////////////////////////////////////////////////////
// IHOBPointInfo wrapper class

class IHOBPointInfo : public COleDispatchDriver
{
public:
	IHOBPointInfo() {}		// Calls COleDispatchDriver default constructor
	IHOBPointInfo(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IHOBPointInfo(const IHOBPointInfo& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	LPDISPATCH GetApplication();
	void SetApplication(LPDISPATCH);
	LPDISPATCH GetParent();
	void SetParent(LPDISPATCH);
	long GetCount();
	void SetCount(long);

// Operations
public:
	long IsVisible(long i_nIndex);
	long GetHideLeader(long i_nIndex);
	long SetHideLeader(long i_nIndex, long i_bNewValue);
};
/////////////////////////////////////////////////////////////////////////////
// IPicture wrapper class

class IPicture : public COleDispatchDriver
{
public:
	IPicture() {}		// Calls COleDispatchDriver default constructor
	IPicture(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IPicture(const IPicture& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:

// Operations
public:
	long GetBitmapDataSize();
	void GetBitmapData(VARIANT* buffer);
};
/////////////////////////////////////////////////////////////////////////////
// IReportData wrapper class

class IReportData : public COleDispatchDriver
{
public:
	IReportData() {}		// Calls COleDispatchDriver default constructor
	IReportData(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	IReportData(const IReportData& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetCurPage();
	void SetCurPage(long);
	CString GetToolkitICommandInstanceGuid();
	void SetToolkitICommandInstanceGuid(LPCTSTR);
	CString GetToolkitIPartProgramManagerInstanceGuid();
	void SetToolkitIPartProgramManagerInstanceGuid(LPCTSTR);

// Operations
public:
	VARIANT GetValue(long DataType, long TypeIndex);
	VARIANT GetValue2(long DataType, long TypeIndex, long FirstArrayIndex, long SecondArrayIndex);
	BOOL HasCommandData();
	LPDISPATCH GetCommand();
	long GetCount(long DataType);
	long GetTolColor(double Deviation, double plustol, double minustol);
	VARIANT GetColorList();
	VARIANT GetReferenceValue(long refValue, long DataType, long TypeIndex);
	VARIANT GetReferenceValue2(long refValue, long DataType, long TypeIndex, long FirstArrayIndex, long SecondArrayIndex);
	VARIANT GetExpressionValue(LPCTSTR Expression);
	BOOL HasToolkitCommandData();
	VARIANT GetCommandData(LPCTSTR _expression, LPCTSTR _option);
};

}
